pterm

package module
v0.0.0-...-8069c1a Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 7, 2024 License: MIT Imports: 28 Imported by: 0

README

💻 PTerm | Pretty Terminal Printer

A modern Go framework to make beautiful CLIs

Latest Release Stars Forks Downloads Forks
Downloads

PTerm

Show Demo Code


PTerm.sh | Installation | Getting Started | Documentation | Examples | Q&A | Discord


📦 Installation

To make PTerm available in your project, you can run the following command.
Make sure to run this command inside your project, when you're using go modules 😉

go get github.com/glados28/pterm

⭐ Main Features

Feature Description
🪀 Easy to use PTerm emphasizes ease of use, with examples and consistent component design.
🤹‍♀️ Cross-Platform PTerm works on various OS and terminals, including Windows CMD, macOS iTerm2, and in CI systems like GitHub Actions.
🧪 Well tested A high test coverage and 28774 automated tests ensure PTerm's reliability.
✨ Consistent Colors PTerm uses the ANSI color scheme for uniformity and supports TrueColor for advanced terminals.
📚 Component system PTerm's flexible Printers can be used individually or combined to generate beautiful console output.
🛠 Configurable PTerm is ready to use without configuration but allows easy customization for unique terminal output.
✏ Documentation Access comprehensive docs on pkg.go.dev and view practical examples in the examples section.

Printers (Components)

Feature Feature Feature Feature Feature
Area
(Examples)
Barchart
(Examples)
Basictext
(Examples)
Bigtext
(Examples)
Box
(Examples)
Bulletlist
(Examples)
Center
(Examples)
Coloring
(Examples)
Header
(Examples)
Heatmap
(Examples)
Interactive confirm
(Examples)
Interactive continue
(Examples)
Interactive multiselect
(Examples)
Interactive select
(Examples)
Interactive textinput
(Examples)
Logger
(Examples)
Multiple-live-printers
(Examples)
Panel
(Examples)
Paragraph
(Examples)
Prefix
(Examples)
Progressbar
(Examples)
Section
(Examples)
Slog
(Examples)
Spinner
(Examples)
Style
(Examples)
Table
(Examples)
Theme
(Examples)
Tree
(Examples)

🦸‍♂️ Sponsors


🧪 Examples


‼️ You can find all the examples, in a much better structure and their source code, in "_examples" ‼️
Click on the link above to show the examples folder.

area/demo

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Print an informational message using PTerm's Info printer.
	// This message will stay in place while the area updates.
	pterm.Info.Println("The previous text will stay in place, while the area updates.")

	// Print two new lines as spacer.
	pterm.Print("\n\n")

	// Start the Area printer from PTerm's DefaultArea, with the Center option.
	// The Area printer allows us to update a specific area of the console output.
	// The returned 'area' object is used to control the area updates.
	area, _ := pterm.DefaultArea.WithCenter().Start()

	// Loop 10 times to update the area with the current time.
	for i := 0; i < 10; i++ {
		// Get the current time, format it as "15:04:05" (hour:minute:second), and convert it to a string.
		// Then, create a BigText from the time string using PTerm's DefaultBigText and putils NewLettersFromString.
		// The Srender() function is used to save the BigText as a string.
		str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender()

		// Update the Area contents with the current time string.
		area.Update(str)

		// Sleep for a second before the next update.
		time.Sleep(time.Second)
	}

	// Stop the Area printer after all updates are done.
	area.Stop()
}

area/center

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Start a new default area in the center of the terminal.
	// The Start() function returns the created area and an error.
	area, _ := pterm.DefaultArea.WithCenter().Start()

	// Loop 5 times to simulate a dynamic update.
	for i := 0; i < 5; i++ {
		// Update the content of the area with the current count.
		// The Sprintf function is used to format the string.
		area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))

		// Pause for a second to simulate a time-consuming task.
		time.Sleep(time.Second)
	}

	// Stop the area after all updates are done.
	area.Stop()
}

area/default

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Start a new default area and get a reference to it.
	// The second return value is an error which is ignored here.
	area, _ := pterm.DefaultArea.Start()

	// Loop 5 times
	for i := 0; i < 5; i++ {
		// Update the content of the area dynamically.
		// Here we're just displaying the current count.
		area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))

		// Pause for a second before the next update.
		time.Sleep(time.Second)
	}

	// Stop the area after all updates are done.
	// This will clean up and free resources used by the area.
	area.Stop()
}

area/dynamic-chart

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Start a new fullscreen centered area.
	// This area will be used to display the bar chart.
	area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()
	// Ensure the area stops updating when we're done.
	defer area.Stop()

	// Loop to update the bar chart 10 times.
	for i := 0; i < 10; i++ {
		// Create a new bar chart with dynamic bars.
		// The bars will change based on the current iteration.
		barchart := pterm.DefaultBarChart.WithBars(dynamicBars(i))
		// Render the bar chart to a string.
		// This string will be used to update the area.
		content, _ := barchart.Srender()
		// Update the area with the new bar chart.
		area.Update(content)
		// Wait for half a second before the next update.
		time.Sleep(500 * time.Millisecond)
	}
}

// dynamicBars generates a set of bars for the bar chart.
// The bars will change based on the current iteration.
func dynamicBars(i int) pterm.Bars {
	return pterm.Bars{
		{Label: "A", Value: 10},     // A static bar.
		{Label: "B", Value: 20 * i}, // A bar that grows with each iteration.
		{Label: "C", Value: 30},     // Another static bar.
		{Label: "D", Value: 40 + i}, // A bar that grows slowly with each iteration.
	}
}

area/fullscreen

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Start a new fullscreen area. This will return an area instance and an error.
	// The underscore (_) is used to ignore the error.
	area, _ := pterm.DefaultArea.WithFullscreen().Start()

	// Loop 5 times to update the area content.
	for i := 0; i < 5; i++ {
		// Update the content of the area with the current count.
		// The Sprintf function is used to format the string.
		area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))

		// Pause for a second before the next update.
		time.Sleep(time.Second)
	}

	// Stop the area after all updates are done.
	area.Stop()
}

area/fullscreen-center

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Initialize a new PTerm area with fullscreen and center options
	// The Start() function returns the created area and an error (ignored here)
	area, _ := pterm.DefaultArea.WithFullscreen().WithCenter().Start()

	// Loop 5 times to demonstrate dynamic content update
	for i := 0; i < 5; i++ {
		// Update the content of the area with the current count
		// The Sprintf function is used to format the string with the count
		area.Update(pterm.Sprintf("Current count: %d\nAreas can update their content dynamically!", i))

		// Pause for a second
		time.Sleep(time.Second)
	}

	// Stop the area after all updates are done
	// This will clear the area and return the terminal to its normal state
	area.Stop()
}

barchart/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the bars for the chart
	bars := []pterm.Bar{
		{Label: "Bar 1", Value: 5},
		{Label: "Bar 2", Value: 3},
		{Label: "Longer Label", Value: 7},
	}

	// Print an informational message
	pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")

	// Create a bar chart with the defined bars and render it
	// The DefaultBarChart is used as a base, and the bars are added with the WithBars option
	// The Render function is then called to display the chart
	pterm.DefaultBarChart.WithBars(bars).Render()

	// Create a horizontal bar chart with the defined bars and render it
	// The DefaultBarChart is used as a base, the chart is made horizontal with the WithHorizontal option, and the bars are added with the WithBars option
	// The Render function is then called to display the chart
	pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}

barchart/custom-height

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define a slice of Bar structs. Each struct represents a bar in the chart.
	// The Label field is the name of the bar and the Value field is the height of the bar.
	bars := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Create and render a bar chart with the defined bars and a height of 5.
	// The WithBars method is used to set the bars of the chart.
	// The WithHeight method is used to set the height of the chart.
	// The Render method is used to display the chart in the terminal.
	pterm.DefaultBarChart.WithBars(bars).WithHeight(5).Render()
}

barchart/custom-width

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the bar chart
	barData := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Create a bar chart with the defined data
	// The chart is horizontal and has a width of 5
	// The Render() function is called to display the chart
	pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithWidth(5).Render()
}

barchart/default

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the bar chart. Each bar is represented by a `pterm.Bar` struct.
	// The `Label` field represents the label of the bar, and the `Value` field represents the value of the bar.
	bars := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Use the `DefaultBarChart` from the `pterm` package to create a bar chart.
	// The `WithBars` method is used to set the bars of the chart.
	// The `Render` method is used to display the chart.
	pterm.DefaultBarChart.WithBars(bars).Render()
}

barchart/horizontal

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the bar chart
	bars := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Create a bar chart with the defined data
	// The chart is displayed horizontally
	// The Render() function is called to display the chart
	pterm.DefaultBarChart.WithBars(bars).WithHorizontal().Render()
}

barchart/horizontal-show-value

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the bar chart
	barData := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Create a bar chart with the defined data
	// The chart is horizontal and displays the value of each bar
	// The Render() function is called to display the chart
	pterm.DefaultBarChart.WithBars(barData).WithHorizontal().WithShowValue().Render()
}

barchart/mixed-values

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define a set of bars for the chart.
	// Each bar has a label and a value.
	bars := []pterm.Bar{
		{Label: "Bar 1", Value: 2},
		{Label: "Bar 2", Value: -3},
		{Label: "Bar 3", Value: -2},
		{Label: "Bar 4", Value: 5},
		{Label: "Longer Label", Value: 7},
	}

	// Print a section header.
	// This is useful for separating different parts of the output.
	pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")

	// Create a bar chart with the defined bars.
	// The chart will display the value of each bar.
	// The Render() function is called to display the chart.
	pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()

	// Create a horizontal bar chart with the same bars.
	// The chart will display the value of each bar.
	// The Render() function is called to display the chart.
	pterm.DefaultBarChart.WithHorizontal().WithBars(bars).WithShowValue().Render()
}

barchart/negative-values

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define a set of bars with negative values.
	// Each bar is represented by a struct with a label and a value.
	negativeBars := pterm.Bars{
		{Label: "Bar 1", Value: -5},
		{Label: "Bar 2", Value: -3},
		{Label: "Longer Label", Value: -7},
	}

	// Print an informational message to the console.
	pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")

	// Create a vertical bar chart with the defined bars.
	// The WithShowValue() option is used to display the value of each bar in the chart.
	// The Render() method is called to draw the chart.
	_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()

	// Create a horizontal bar chart with the same bars.
	// The WithHorizontal() option is used to orient the chart horizontally.
	// The WithShowValue() option and Render() method are used in the same way as before.
	_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}

barchart/show-value

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define a slice of bars for the bar chart. Each bar is represented by a struct
	// with a Label and a Value. The Label is a string that represents the name of the bar,
	// and the Value is an integer that represents the height of the bar.
	bars := []pterm.Bar{
		{Label: "A", Value: 10},
		{Label: "B", Value: 20},
		{Label: "C", Value: 30},
		{Label: "D", Value: 40},
		{Label: "E", Value: 50},
		{Label: "F", Value: 40},
		{Label: "G", Value: 30},
		{Label: "H", Value: 20},
		{Label: "I", Value: 10},
	}

	// Create a bar chart with the defined bars using the DefaultBarChart object from PTerm.
	// Chain the WithBars method to set the bars of the chart.
	// Chain the WithShowValue method to display the value of each bar on the chart.
	// Finally, call the Render method to display the chart.
	pterm.DefaultBarChart.WithBars(bars).WithShowValue().Render()
}

basictext/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// The DefaultBasicText is a basic text printer provided by PTerm.
	// It is used to print text without any special formatting.
	pterm.DefaultBasicText.Println("Default basic text printer.")

	// The DefaultBasicText can be used in any context that requires a TextPrinter.
	// Here, we're using it with the LightMagenta function to color a portion of the text.
	pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")

	// The DefaultBasicText is also useful for resolving progress bars and spinners.
}

bigtext/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Create a large text with the LetterStyle from the standard theme.
	// This is useful for creating title screens.
	pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Render()

	// Create a large text with differently colored letters.
	// Here, the first letter 'P' is colored cyan and the rest 'Term' is colored light magenta.
	// This can be used to highlight specific parts of the text.
	pterm.DefaultBigText.WithLetters(
		putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
		putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle()),
	).Render()

	// Create a large text with a specific RGB color.
	// This can be used when you need a specific color that is not available in the standard colors.
	// Here, the color is gold (RGB: 255, 215, 0).
	pterm.DefaultBigText.WithLetters(
		putils.LettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0)),
	).Render()
}

bigtext/colored

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Initialize a big text display with the letters "P" and "Term"
	// "P" is displayed in cyan and "Term" is displayed in light magenta
	pterm.DefaultBigText.WithLetters(
		putils.LettersFromStringWithStyle("P", pterm.FgCyan.ToStyle()),
		putils.LettersFromStringWithStyle("Term", pterm.FgLightMagenta.ToStyle())).
		Render() // Render the big text to the terminal
}

bigtext/default

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Define the text to be rendered
	var text = "PTerm"

	// Convert the text into a format suitable for PTerm
	var letters = putils.LettersFromString(text)

	// Render the text using PTerm's default big text style
	pterm.DefaultBigText.WithLetters(letters).Render()
}

box/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Print an informational message.
	pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs")

	// Create three panels with text, some of them with titles.
	// The panels are created using the DefaultBox style.
	panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
	panel2 := pterm.DefaultBox.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
	panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")

	// Combine the panels into a layout using the DefaultPanel style.
	// The layout is a 2D grid, with each row being an array of panels.
	// In this case, the first row contains panel1 and panel2, and the second row contains only panel3.
	panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
		{{Data: panel1}, {Data: panel2}},
		{{Data: panel3}},
	}).Srender()

	// Print the panels layout inside a box with a title.
	// The box is created using the DefaultBox style, with the title positioned at the bottom right.
	pterm.DefaultBox.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}

box/custom-padding

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a default box with custom padding options and print "Hello, World!" inside it.
	pterm.DefaultBox.WithRightPadding(10).WithLeftPadding(10).WithTopPadding(2).WithBottomPadding(2).Println("Hello, World!")
}

box/default

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a default box with PTerm and print a message in it.
	// The DefaultBox.Println method automatically starts, prints the message, and stops the box.
	pterm.DefaultBox.Println("Hello, World!")
}

box/title

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a default box with specified padding
	paddedBox := pterm.DefaultBox.WithLeftPadding(4).WithRightPadding(4).WithTopPadding(1).WithBottomPadding(1)

	// Define a title for the box
	title := pterm.LightRed("I'm a box!")

	// Create boxes with the title positioned differently and containing different content
	box1 := paddedBox.WithTitle(title).Sprint("Hello, World!\n      1")                         // Title at default position (top left)
	box2 := paddedBox.WithTitle(title).WithTitleTopCenter().Sprint("Hello, World!\n      2")    // Title at top center
	box3 := paddedBox.WithTitle(title).WithTitleTopRight().Sprint("Hello, World!\n      3")     // Title at top right
	box4 := paddedBox.WithTitle(title).WithTitleBottomRight().Sprint("Hello, World!\n      4")  // Title at bottom right
	box5 := paddedBox.WithTitle(title).WithTitleBottomCenter().Sprint("Hello, World!\n      5") // Title at bottom center
	box6 := paddedBox.WithTitle(title).WithTitleBottomLeft().Sprint("Hello, World!\n      6")   // Title at bottom left
	box7 := paddedBox.WithTitle(title).WithTitleTopLeft().Sprint("Hello, World!\n      7")      // Title at top left

	// Render the boxes in a panel layout
	pterm.DefaultPanel.WithPanels([][]pterm.Panel{
		{{box1}, {box2}, {box3}},
		{{box4}, {box5}, {box6}},
		{{box7}},
	}).Render()
}

bulletlist/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Define a list of bullet list items with different levels.
	bulletListItems := []pterm.BulletListItem{
		{Level: 0, Text: "Level 0"}, // Level 0 item
		{Level: 1, Text: "Level 1"}, // Level 1 item
		{Level: 2, Text: "Level 2"}, // Level 2 item
	}

	// Use the default bullet list style to render the list items.
	pterm.DefaultBulletList.WithItems(bulletListItems).Render()

	// Define a string with different levels of indentation.
	text := `0
 1
  2
   3`

	// Convert the indented string to a bullet list and render it.
	putils.BulletListFromString(text, " ").Render()
}

bulletlist/customized

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define a list of bullet list items with different styles and levels.
	bulletListItems := []pterm.BulletListItem{
		{
			Level:       0,                            // Level 0 (top level)
			Text:        "Blue",                       // Text to display
			TextStyle:   pterm.NewStyle(pterm.FgBlue), // Text color
			BulletStyle: pterm.NewStyle(pterm.FgRed),  // Bullet color
		},
		{
			Level:       1,                                  // Level 1 (sub-item)
			Text:        "Green",                            // Text to display
			TextStyle:   pterm.NewStyle(pterm.FgGreen),      // Text color
			Bullet:      "-",                                // Custom bullet symbol
			BulletStyle: pterm.NewStyle(pterm.FgLightWhite), // Bullet color
		},
		{
			Level:       2,                              // Level 2 (sub-sub-item)
			Text:        "Cyan",                         // Text to display
			TextStyle:   pterm.NewStyle(pterm.FgCyan),   // Text color
			Bullet:      ">",                            // Custom bullet symbol
			BulletStyle: pterm.NewStyle(pterm.FgYellow), // Bullet color
		},
	}

	// Create a bullet list with the defined items and render it.
	pterm.DefaultBulletList.WithItems(bulletListItems).Render()
}

center/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Print a block of text centered in the terminal
	pterm.DefaultCenter.Println("This text is centered!\nIt centers the whole block by default.\nIn that way you can do stuff like this:")

	// Generate BigLetters and store in 's'
	s, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString("PTerm")).Srender()

	// Print the BigLetters 's' centered in the terminal
	pterm.DefaultCenter.Println(s)

	// Print each line of the text separately centered in the terminal
	pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}

coloring/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a table with different foreground and background colors.
	pterm.DefaultTable.WithData([][]string{
		{pterm.FgBlack.Sprint("Black"), pterm.FgRed.Sprint("Red"), pterm.FgGreen.Sprint("Green"), pterm.FgYellow.Sprint("Yellow")},
		{"", pterm.FgLightRed.Sprint("Light Red"), pterm.FgLightGreen.Sprint("Light Green"), pterm.FgLightYellow.Sprint("Light Yellow")},
		{pterm.BgBlack.Sprint("Black"), pterm.BgRed.Sprint("Red"), pterm.BgGreen.Sprint("Green"), pterm.BgYellow.Sprint("Yellow")},
		{"", pterm.BgLightRed.Sprint("Light Red"), pterm.BgLightGreen.Sprint("Light Green"), pterm.BgLightYellow.Sprint("Light Yellow")},
		{pterm.FgBlue.Sprint("Blue"), pterm.FgMagenta.Sprint("Magenta"), pterm.FgCyan.Sprint("Cyan"), pterm.FgWhite.Sprint("White")},
		{pterm.FgLightBlue.Sprint("Light Blue"), pterm.FgLightMagenta.Sprint("Light Magenta"), pterm.FgLightCyan.Sprint("Light Cyan"), pterm.FgLightWhite.Sprint("Light White")},
		{pterm.BgBlue.Sprint("Blue"), pterm.BgMagenta.Sprint("Magenta"), pterm.BgCyan.Sprint("Cyan"), pterm.BgWhite.Sprint("White")},
		{pterm.BgLightBlue.Sprint("Light Blue"), pterm.BgLightMagenta.Sprint("Light Magenta"), pterm.BgLightCyan.Sprint("Light Cyan"), pterm.BgLightWhite.Sprint("Light White")},
	}).Render() // Render the table.

	pterm.Println()

	// Print words in different colors.
	pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
	pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))

	pterm.Println()

	// Create a new style with a red background, light green foreground, and bold text.
	style := pterm.NewStyle(pterm.BgRed, pterm.FgLightGreen, pterm.Bold)
	// Print text using the created style.
	style.Println("This text uses a style and is bold and light green with a red background!")
}

coloring/disable-output

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Loop from 0 to 14
	for i := 0; i < 15; i++ {
		switch i {
		case 5:
			// At the 5th iteration, print a message and disable the output
			pterm.Info.Println("Disabled Output!")
			pterm.DisableOutput()
		case 10:
			// At the 10th iteration, enable the output and print a message
			pterm.EnableOutput()
			pterm.Info.Println("Enabled Output!")
		}

		// Print a progress message for each iteration
		pterm.Printf("Printing something... [%d/%d]\n", i, 15)
	}
}

coloring/fade-colors

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Print an informational message.
	pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")

	// Define the start and end points for the color gradient.
	startColor := pterm.NewRGB(0, 255, 255) // Cyan
	endColor := pterm.NewRGB(255, 0, 255)   // Magenta

	// Get the terminal height to determine the gradient range.
	terminalHeight := pterm.GetTerminalHeight()

	// Loop over the range of the terminal height to create a color gradient.
	for i := 0; i < terminalHeight-2; i++ {
		// Calculate the fade factor for the current step in the gradient.
		fadeFactor := float32(i) / float32(terminalHeight-2)

		// Create a color that represents the current step in the gradient.
		currentColor := startColor.Fade(0, 1, fadeFactor, endColor)

		// Print a string with the current color.
		currentColor.Println("Hello, World!")
	}
}

coloring/fade-colors-rgb-style

Animation

SHOW SOURCE
package main

import (
	"strings"

	"github.com/glados28/pterm"
)

func main() {
	// Define RGB colors
	white := pterm.NewRGB(255, 255, 255)
	grey := pterm.NewRGB(128, 128, 128)
	black := pterm.NewRGB(0, 0, 0)
	red := pterm.NewRGB(255, 0, 0)
	purple := pterm.NewRGB(255, 0, 255)
	green := pterm.NewRGB(0, 255, 0)

	// Define strings to be printed
	str1 := "RGB colors only work in Terminals which support TrueColor."
	str2 := "The background and foreground colors can be customized individually."
	str3 := "Styles can also be applied. For example: Bold or Italic."

	// Print first string with color fading from white to purple
	printFadedString(str1, white, purple, grey, black)

	// Print second string with color fading from purple to red
	printFadedString(str2, black, purple, red, red)

	// Print third string with color fading from white to green and style changes
	printStyledString(str3, white, green, red, black)
}

// printFadedString prints a string with color fading effect
func printFadedString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
	strs := strings.Split(str, "")
	var result string
	for i := 0; i < len(str); i++ {
		// Create a style with color fading effect
		style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
		// Append styled letter to result string
		result += style.Sprint(strs[i])
	}
	pterm.Println(result)
}

// printStyledString prints a string with color fading and style changes
func printStyledString(str string, fgStart, fgEnd, bgStart, bgEnd pterm.RGB) {
	strs := strings.Split(str, "")
	var result string
	boldStr := strings.Split("Bold", "")
	italicStr := strings.Split("Italic", "")
	bold, italic := 0, 0
	for i := 0; i < len(str); i++ {
		// Create a style with color fading effect
		style := pterm.NewRGBStyle(fgStart.Fade(0, float32(len(str)), float32(i), fgEnd), bgStart.Fade(0, float32(len(str)), float32(i), bgEnd))
		// Check if the next letters are "Bold" or "Italic" and add the corresponding style
		if bold < len(boldStr) && i+len(boldStr)-bold <= len(strs) && strings.Join(strs[i:i+len(boldStr)-bold], "") == strings.Join(boldStr[bold:], "") {
			style = style.AddOptions(pterm.Bold)
			bold++
		} else if italic < len(italicStr) && i+len(italicStr)-italic < len(strs) && strings.Join(strs[i:i+len(italicStr)-italic], "") == strings.Join(italicStr[italic:], "") {
			style = style.AddOptions(pterm.Italic)
			italic++
		}
		// Append styled letter to result string
		result += style.Sprint(strs[i])
	}
	pterm.Println(result)
}

coloring/fade-multiple-colors

Animation

SHOW SOURCE
package main

import (
	"strings"

	"github.com/glados28/pterm"
)

func main() {
	// Define RGB values for gradient points.
	startColor := pterm.NewRGB(0, 255, 255)
	firstPoint := pterm.NewRGB(255, 0, 255)
	secondPoint := pterm.NewRGB(255, 0, 0)
	thirdPoint := pterm.NewRGB(0, 255, 0)
	endColor := pterm.NewRGB(255, 255, 255)

	// Define the string to be printed.
	str := "RGB colors only work in Terminals which support TrueColor."
	strs := strings.Split(str, "")

	// Initialize an empty string for the faded info.
	var fadeInfo string

	// Loop over the string length to create a gradient effect.
	for i := 0; i < len(str); i++ {
		// Append each character of the string with a faded color to the info string.
		fadeInfo += startColor.Fade(0, float32(len(str)), float32(i), firstPoint).Sprint(strs[i])
	}

	// Print the info string with gradient effect.
	pterm.Info.Println(fadeInfo)

	// Get the terminal height.
	terminalHeight := pterm.GetTerminalHeight()

	// Loop over the terminal height to print "Hello, World!" with a gradient effect.
	for i := 0; i < terminalHeight-2; i++ {
		// Print the string with a color that fades from startColor to endColor.
		startColor.Fade(0, float32(terminalHeight-2), float32(i), firstPoint, secondPoint, thirdPoint, endColor).Println("Hello, World!")
	}
}

coloring/override-default-printers

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Print a default error message with PTerm's built-in Error style.
	pterm.Error.Println("This is the default Error")

	// Override the default error prefix with a new text and style.
	pterm.Error.Prefix = pterm.Prefix{Text: "OVERRIDE", Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed)}

	// Print the error message again, this time with the overridden prefix.
	pterm.Error.Println("This is the default Error after the prefix was overridden")
}

coloring/print-color-rgb

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a new RGB color with values 178, 44, 199.
	// This color will be used for the text.
	pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")

	// Create a new RGB color with values 15, 199, 209.
	// This color will be used for the text.
	pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")

	// Create a new RGB color with values 201, 144, 30.
	// This color will be used for the background.
	// The 'true' argument indicates that the color is for the background.
	pterm.NewRGB(201, 144, 30, true).Println("This text is printed with a custom RGB background!")
}

coloring/print-color-rgb-style

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define RGB colors for foreground and background.
	foregroundRGB := pterm.RGB{R: 187, G: 80, B: 0}
	backgroundRGB := pterm.RGB{R: 0, G: 50, B: 123}

	// Create a new RGB style with the defined foreground and background colors.
	rgbStyle := pterm.NewRGBStyle(foregroundRGB, backgroundRGB)

	// Print a string with the custom RGB style.
	rgbStyle.Println("This text is not styled.")

	// Add the 'Bold' option to the RGB style and print a string with this style.
	rgbStyle.AddOptions(pterm.Bold).Println("This text is bold.")

	// Add the 'Italic' option to the RGB style and print a string with this style.
	rgbStyle.AddOptions(pterm.Italic).Println("This text is italic.")
}

demo/demo

Animation

SHOW SOURCE
package main

import (
	"flag"
	"math/rand"
	"reflect"
	"strconv"
	"strings"
	"time"

	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

// Speed the demo up, by setting this flag.
// Usefull for debugging.
// Example:
//
//	go run main.go -speedup
var speedup = flag.Bool("speedup", false, "Speed up the demo")
var skipIntro = flag.Bool("skip-intro", false, "Skips the intro")
var second = time.Second

var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

func main() {
	setup() // Setup the demo (flags etc.)

	// Show intro
	if !*skipIntro {
		introScreen()
		clear()
	}

	showcase("Structured Logging", 5, func() {
		logger := pterm.DefaultLogger.
			WithLevel(pterm.LogLevelTrace)

		logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))

		time.Sleep(time.Second * 3)

		interstingStuff := map[string]any{
			"when were crayons invented":  "1903",
			"what is the meaning of life": 42,
			"is this interesting":         true,
		}
		logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))
		time.Sleep(time.Second * 3)

		logger.Info("That was actually interesting", logger.Args("such", "wow"))
		time.Sleep(time.Second * 3)
		logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
		time.Sleep(time.Second * 3)
		logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
		time.Sleep(time.Second * 3)
		logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
	})

	showcase("Progress bar", 2, func() {
		pb, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
		for i := 0; i < pb.Total; i++ {
			pb.UpdateTitle("Installing " + pseudoProgramList[i])
			if pseudoProgramList[i] == "pseudo-minecraft" {
				pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
			} else {
				pterm.Success.Println("Installing " + pseudoProgramList[i])
			}
			pb.Increment()
			time.Sleep(second / 2)
		}
		pb.Stop()
	})

	showcase("Spinner", 2, func() {
		list := pseudoProgramList[7:]
		spinner, _ := pterm.DefaultSpinner.Start("Installing stuff")
		for i := 0; i < len(list); i++ {
			spinner.UpdateText("Installing " + list[i])
			if list[i] == "pseudo-minecraft" {
				pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
			} else {
				pterm.Success.Println("Installing " + list[i])
			}
			time.Sleep(second)
		}
		spinner.Success()
	})

	showcase("Live Output", 2, func() {
		pterm.Info.Println("You can use an Area to display changing output:")
		pterm.Println()
		area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
		for i := 0; i < 10; i++ {
			str, _ := pterm.DefaultBigText.WithLetters(putils.LettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
			area.Update(str)                                                                                              // Update Area contents.
			time.Sleep(time.Second)
		}
		area.Stop()
	})

	showcase("Tables", 4, func() {
		for i := 0; i < 3; i++ {
			pterm.Println()
		}
		td := [][]string{
			{"Library", "Description"},
			{"PTerm", "Make beautiful CLIs"},
			{"Testza", "Programmer friendly test framework"},
			{"Cursor", "Move the cursor around the terminal"},
		}
		table, _ := pterm.DefaultTable.WithHasHeader().WithData(td).Srender()
		boxedTable, _ := pterm.DefaultTable.WithHasHeader().WithData(td).WithBoxed().Srender()
		pterm.DefaultCenter.Println(table)
		pterm.DefaultCenter.Println(boxedTable)
	})

	showcase("TrueColor Support", 7, func() {
		from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
		to := pterm.NewRGB(255, 0, 255)   // This RGB value is used as the gradients first point.

		str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)\n\nLorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."
		strs := strings.Split(str, "")
		var fadeInfo string // String which will be used to print info.
		// For loop over the range of the string length.
		for i := 0; i < len(str); i++ {
			// Append faded letter to info string.
			fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
		}
		pterm.DefaultCenter.WithCenterEachLineSeparately().Println(fadeInfo)
	})

	showcase("Fully Customizable", 2, func() {
		for i := 0; i < 4; i++ {
			pterm.Println()
		}
		text := "All printers are fully customizable!"
		area := pterm.DefaultArea.WithCenter()
		area.Update(pterm.DefaultBox.Sprintln(text))
		time.Sleep(second)
		area.Update(pterm.DefaultBox.WithTopPadding(1).Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopLeft().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopCenter().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleTopRight().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomRight().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomCenter().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithTitle("Some title!").WithTitleBottomLeft().Sprintln(text))
		time.Sleep(second / 3)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgCyan)).Sprintln(text))
		time.Sleep(second / 5)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgRed)).Sprintln(text))
		time.Sleep(second / 5)
		area.Update(pterm.DefaultBox.WithTopPadding(1).WithBottomPadding(1).WithLeftPadding(1).WithRightPadding(1).WithBoxStyle(pterm.NewStyle(pterm.FgGreen)).Sprintln(text))
		time.Sleep(second / 5)
		area.Update(pterm.DefaultBox.WithTopPadding(1).
			WithBottomPadding(1).
			WithLeftPadding(1).
			WithRightPadding(1).
			WithHorizontalString("═").
			WithVerticalString("║").
			WithBottomLeftCornerString("╗").
			WithBottomRightCornerString("╔").
			WithTopLeftCornerString("╝").
			WithTopRightCornerString("╚").
			Sprintln(text))
		area.Stop()
	})

	showcase("Themes", 2, func() {
		pterm.Info.Println("You can change the color theme of PTerm easily to fit your needs!\nThis is the default one:")
		time.Sleep(second / 2)
		// Print every value of the default theme with its own style.
		v := reflect.ValueOf(pterm.ThemeDefault)
		typeOfS := v.Type()

		if typeOfS == reflect.TypeOf(pterm.Theme{}) {
			for i := 0; i < v.NumField(); i++ {
				field, ok := v.Field(i).Interface().(pterm.Style)
				if ok {
					field.Println(typeOfS.Field(i).Name)
				}
				time.Sleep(time.Millisecond * 250)
			}
		}
	})

	showcase("And much more!", 3, func() {
		for i := 0; i < 4; i++ {
			pterm.Println()
		}
		box := pterm.DefaultBox.
			WithBottomPadding(1).
			WithTopPadding(1).
			WithLeftPadding(3).
			WithRightPadding(3).
			Sprintf("Have fun exploring %s!", pterm.Cyan("PTerm"))
		pterm.DefaultCenter.Println(box)
	})
}

func setup() {
	flag.Parse()
	if *speedup {
		second = time.Millisecond * 200
	}
}

func introScreen() {
	ptermLogo, _ := pterm.DefaultBigText.WithLetters(
		putils.LettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
		putils.LettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
		Srender()

	pterm.DefaultCenter.Print(ptermLogo)

	pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("PTDP - PTerm Demo Program"))

	pterm.Info.Println("This animation was generated with the latest version of PTerm!" +
		"\nPTerm works on nearly every terminal and operating system." +
		"\nIt's super easy to use!" +
		"\nIf you want, you can customize everything :)" +
		"\nYou can see the code of this demo in the " + pterm.LightMagenta("./_examples/demo") + " directory." +
		"\n" +
		"\nThis demo was updated at: " + pterm.Green(time.Now().Format("02 Jan 2006 - 15:04:05 MST")))
	pterm.Println()
	introSpinner, _ := pterm.DefaultSpinner.WithShowTimer(false).WithRemoveWhenDone(true).Start("Waiting for 15 seconds...")
	time.Sleep(second)
	for i := 14; i > 0; i-- {
		if i > 1 {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " seconds...")
		} else {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " second...")
		}
		time.Sleep(second)
	}
	introSpinner.Stop()
}

func clear() {
	print("\033[H\033[2J")
}

func showcase(title string, seconds int, content func()) {
	pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithFullWidth().Println(title)
	pterm.Println()
	time.Sleep(second / 2)
	content()
	time.Sleep(second * time.Duration(seconds))
	print("\033[H\033[2J")
}

func randomInt(min, max int) int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(max-min+1) + min
}

header/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Print a default header.
	// This uses the default settings of PTerm to print a header.
	pterm.DefaultHeader.Println("This is the default header!")

	// Print a spacer line for better readability.
	pterm.Println()

	// Print a full-width header.
	// This uses the WithFullWidth() option of PTerm to print a header that spans the full width of the terminal.
	pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}

header/custom

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Customize the DefaultHeader with a cyan background, black text, and a margin of 15.
	pterm.DefaultHeader.WithMargin(15).WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).WithTextStyle(pterm.NewStyle(pterm.FgBlack)).Println("This is a custom header!")

	// Define a new HeaderPrinter with a red background, black text, and a margin of 20.
	newHeader := pterm.HeaderPrinter{
		TextStyle:       pterm.NewStyle(pterm.FgBlack),
		BackgroundStyle: pterm.NewStyle(pterm.BgRed),
		Margin:          20,
	}

	// Print the custom header using the new HeaderPrinter.
	newHeader.Println("This is a custom header!")
}

heatmap/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the data for the heatmap. Each sub-array represents a row in the heatmap.
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the labels for the X and Y axes of the heatmap.
	headerData := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Create a heatmap with the defined data and axis labels, and enable RGB colors.
	// Then render the heatmap.
	pterm.DefaultHeatmap.WithAxisData(headerData).WithData(data).WithEnableRGB().Render()
}

heatmap/custom_colors

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the data for the heatmap
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the axis labels for the heatmap
	headerData := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Print an informational message
	pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and a legend.")
	pterm.Println()

	// Create the heatmap with the defined data and options, and render it
	pterm.DefaultHeatmap.
		WithData(data).
		WithBoxed(false).
		WithAxisData(headerData).
		WithLegend(false).
		WithColors(pterm.BgBlue, pterm.BgRed, pterm.BgGreen, pterm.BgYellow).
		WithLegend().
		Render()
}

heatmap/custom_legend

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the data for the heatmap
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the header data for the heatmap
	headerData := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Print an informational message
	pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a custom legend.")
	pterm.Println()

	// Create the heatmap with the defined data and options
	// Options are chained in a single line for simplicity
	pterm.DefaultHeatmap.
		WithData(data).
		WithBoxed(false).
		WithAxisData(headerData).
		WithEnableRGB().
		WithLegendLabel("custom").
		WithLegendOnlyColoredCells().
		Render() // Render the heatmap
}

heatmap/custom_rgb

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the data for the heatmap.
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the axis labels for the heatmap.
	axisLabels := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Print an informational message.
	pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
	pterm.Println()

	// Define the color range for the heatmap.
	rgbRange := []pterm.RGB{
		pterm.NewRGB(0, 0, 255),
		pterm.NewRGB(255, 0, 0),
		pterm.NewRGB(0, 255, 0),
		pterm.NewRGB(255, 255, 0),
	}

	// Create and render the heatmap.
	pterm.DefaultHeatmap.
		WithData(data).
		WithBoxed(false).
		WithAxisData(axisLabels).
		WithEnableRGB().
		WithRGBRange(rgbRange...).
		Render()
}

heatmap/no_grid

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define the data for the heatmap.
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the axis data for the heatmap.
	axisData := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Print an informational message.
	pterm.Info.Println("The following table has rgb (not supported by every terminal), axis data and a legend.")
	pterm.Println()

	// Create the heatmap with the defined data and options, then render it.
	pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(axisData).WithEnableRGB().WithLegend().WithGrid(false).Render()
}

heatmap/separated

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the heatmap.
	data := [][]float32{
		{0.9, 0.2, -0.7, 0.4, -0.5, 0.6, -0.3, 0.8, -0.1, -1.0, 0.1, -0.8, 0.3},
		{0.2, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3, 0.5, 0.9, -0.9, -0.7, -0.5, -0.3},
		{0.4, 0.4, -0.3, -1.0, 0.3, -0.2, -0.9, 0.5, -0.3, -1.0, 0.6, -0.2, -0.9},
		{0.9, -0.5, -0.1, 0.3, 1, -0.7, -0.3, 0.1, 0.7, -0.9, -0.5, 0.2, 0.6},
		{0.5, 0.6, 0.1, -0.2, -0.7, 0.8, 0.6, 0.1, -0.5, -0.7, 0.7, 0.3, 0.0},
	}

	// Define the axis labels for the heatmap.
	headerData := pterm.HeatmapAxis{
		XAxis: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"},
		YAxis: []string{"1", "2", "3", "4", "5"},
	}

	// Print an informational message.
	pterm.Info.Println("The following table has no rgb (supported by every terminal), no axis data and no legend.")
	pterm.Println()

	// Create the heatmap with the specified data and options, and render it.
	pterm.DefaultHeatmap.WithData(data).WithBoxed(false).WithAxisData(headerData).WithLegend(false).Render()
}

interactive_confirm/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Show an interactive confirmation dialog and get the result.
	result, _ := pterm.DefaultInteractiveConfirm.Show()

	// Print a blank line for better readability.
	pterm.Println()

	// Print the user's answer in a formatted way.
	pterm.Info.Printfln("You answered: %s", boolToText(result))
}

// boolToText converts a boolean value to a colored text.
// If the value is true, it returns a green "Yes".
// If the value is false, it returns a red "No".
func boolToText(b bool) string {
	if b {
		return pterm.Green("Yes")
	}
	return pterm.Red("No")
}

interactive_continue/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Create an interactive continue prompt with default settings
	// This will pause the program execution until the user presses enter
	// The message displayed is "Press 'Enter' to continue..."
	prompt := pterm.DefaultInteractiveContinue

	// Show the prompt and wait for user input
	// The returned result is the user's input (should be empty as it's a continue prompt)
	// The second return value is an error which is ignored here
	result, _ := prompt.Show()

	// Print a blank line for better readability
	pterm.Println()

	// Print the user's input with an info prefix
	// As this is a continue prompt, the input should be empty
	pterm.Info.Printfln("You answered: %s", result)
}

interactive_multiselect/demo

Animation

SHOW SOURCE
package main

import (
	"fmt"
	"github.com/glados28/pterm"
)

func main() {
	// Initialize an empty slice to hold the options.
	var options []string

	// Populate the options slice with 100 options.
	for i := 0; i < 100; i++ {
		options = append(options, fmt.Sprintf("Option %d", i))
	}

	// Add 5 more options to the slice, indicating the availability of fuzzy searching.
	for i := 0; i < 5; i++ {
		options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
	}

	// Use PTerm's interactive multiselect to present the options to the user and capture their selections.
	// The Show() method displays the options and waits for user input.
	selectedOptions, _ := pterm.DefaultInteractiveMultiselect.WithOptions(options).Show()

	// Print the selected options, highlighted in green.
	pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}

interactive_multiselect/custom-checkmarks

Animation

SHOW SOURCE
package main

import (
	"fmt"
	"github.com/glados28/pterm"
)

func main() {
	// Initialize an empty slice to hold the options
	var options []string

	// Populate the options slice with 5 options
	for i := 0; i < 5; i++ {
		options = append(options, fmt.Sprintf("Option %d", i))
	}

	// Create a new interactive multiselect printer with the options
	// Disable the filter and define the checkmark symbols
	printer := pterm.DefaultInteractiveMultiselect.
		WithOptions(options).
		WithFilter(false).
		WithCheckmark(&pterm.Checkmark{Checked: pterm.Green("+"), Unchecked: pterm.Red("-")})

	// Show the interactive multiselect and get the selected options
	selectedOptions, _ := printer.Show()

	// Print the selected options
	pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}

interactive_multiselect/custom-keys

Animation

SHOW SOURCE
package main

import (
	"atomicgo.dev/keyboard/keys"
	"fmt"
	"github.com/glados28/pterm"
)

func main() {
	// Initialize an empty slice to hold the options
	var options []string

	// Populate the options slice with 5 options
	for i := 0; i < 5; i++ {
		options = append(options, fmt.Sprintf("Option %d", i))
	}

	// Create a new interactive multiselect printer with the options
	// Disable the filter and set the keys for confirming and selecting options
	printer := pterm.DefaultInteractiveMultiselect.
		WithOptions(options).
		WithFilter(false).
		WithKeyConfirm(keys.Enter).
		WithKeySelect(keys.Space)

	// Show the interactive multiselect and get the selected options
	selectedOptions, _ := printer.Show()

	// Print the selected options
	pterm.Info.Printfln("Selected options: %s", pterm.Green(selectedOptions))
}

interactive_select/demo

Animation

SHOW SOURCE
package main

import (
	"fmt"
	"github.com/glados28/pterm"
)

func main() {
	// Initialize an empty slice to hold the options
	var options []string

	// Generate 100 options and add them to the options slice
	for i := 0; i < 100; i++ {
		options = append(options, fmt.Sprintf("Option %d", i))
	}

	// Generate 5 additional options with a specific message and add them to the options slice
	for i := 0; i < 5; i++ {
		options = append(options, fmt.Sprintf("You can use fuzzy searching (%d)", i))
	}

	// Use PTerm's interactive select feature to present the options to the user and capture their selection
	// The Show() method displays the options and waits for the user's input
	selectedOption, _ := pterm.DefaultInteractiveSelect.WithOptions(options).Show()

	// Display the selected option to the user with a green color for emphasis
	pterm.Info.Printfln("Selected option: %s", pterm.Green(selectedOption))
}

interactive_textinput/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Create an interactive text input with single line input mode and show it
	result, _ := pterm.DefaultInteractiveTextInput.Show()

	// Print a blank line for better readability
	pterm.Println()

	// Print the user's answer with an info prefix
	pterm.Info.Printfln("You answered: %s", result)
}

interactive_textinput/default-value

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Create an interactive text input with single line input mode and show it
	result, _ := pterm.DefaultInteractiveTextInput.WithDefaultValue("Some default value").Show()

	// Print a blank line for better readability
	pterm.Println()

	// Print the user's answer with an info prefix
	pterm.Info.Printfln("You answered: %s", result)
}

interactive_textinput/multi-line

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Create a default interactive text input with multi-line enabled.
	// This allows the user to input multiple lines of text.
	textInput := pterm.DefaultInteractiveTextInput.WithMultiLine()

	// Show the text input to the user and store the result.
	// The second return value (an error) is ignored with '_'.
	result, _ := textInput.Show()

	// Print a blank line for better readability in the output.
	pterm.Println()

	// Print the user's input prefixed with an informational message.
	// The '%s' placeholder is replaced with the user's input.
	pterm.Info.Printfln("You answered: %s", result)
}

interactive_textinput/password

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create an interactive text input with a mask for password input
	passwordInput := pterm.DefaultInteractiveTextInput.WithMask("*")

	// Show the password input prompt and store the result
	result, _ := passwordInput.Show("Enter your password")

	// Get the default logger from PTerm
	logger := pterm.DefaultLogger

	// Log the received password (masked)
	// Note: In a real-world application, you should never log passwords
	logger.Info("Password received", logger.Args("password", result))
}

logger/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"time"
)

func main() {
	// Create a logger with trace level
	logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)

	// Log a trace level message
	logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))

	// Pause for 3 seconds
	sleep()

	// Define a map with interesting stuff
	interstingStuff := map[string]any{
		"when were crayons invented":  "1903",
		"what is the meaning of life": 42,
		"is this interesting":         true,
	}

	// Log a debug level message with arguments from the map
	logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))

	// Pause for 3 seconds
	sleep()

	// Log an info level message
	logger.Info("That was actually interesting", logger.Args("such", "wow"))

	// Pause for 3 seconds
	sleep()

	// Log a warning level message
	logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))

	// Pause for 3 seconds
	sleep()

	// Log an error level message
	logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))

	// Pause for 3 seconds
	sleep()

	// Log an info level message with a long text that will be automatically wrapped
	logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))

	// Pause for 3 seconds
	sleep()

	// Log a fatal level message
	logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}

// Function to pause the execution for 3 seconds
func sleep() {
	time.Sleep(time.Second * 3)
}

logger/custom-key-styles

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a logger with a level of Trace or higher.
	logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)

	// Define a new style for the "priority" key.
	priorityStyle := map[string]pterm.Style{
		"priority": *pterm.NewStyle(pterm.FgRed),
	}

	// Overwrite all key styles with the new map.
	logger = logger.WithKeyStyles(priorityStyle)

	// Log an info message. The "priority" key will be displayed in red.
	logger.Info("The priority key should now be red", logger.Args("priority", "low", "foo", "bar"))

	// Define a new style for the "foo" key.
	fooStyle := *pterm.NewStyle(pterm.FgBlue)

	// Append the new style to the existing ones.
	logger.AppendKeyStyle("foo", fooStyle)

	// Log another info message. The "foo" key will be displayed in blue.
	logger.Info("The foo key should now be blue", logger.Args("priority", "low", "foo", "bar"))
}

logger/default

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"time"
)

func main() {
	// Create a logger with a level of Trace or higher.
	logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace)

	// Log a trace message with additional arguments.
	logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))

	// Create a map of interesting stuff.
	interstingStuff := map[string]any{
		"when were crayons invented":  "1903",
		"what is the meaning of life": 42,
		"is this interesting":         true,
	}

	// Log a debug message with arguments from a map.
	logger.Debug("This might be interesting", logger.ArgsFromMap(interstingStuff))

	// Log an info message with additional arguments.
	logger.Info("That was actually interesting", logger.Args("such", "wow"))

	// Log a warning message with additional arguments.
	logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))

	// Log an error message with additional arguments.
	logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))

	// Log an info message with additional arguments. PTerm will automatically wrap long logs.
	logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))

	// Pause for 2 seconds.
	time.Sleep(time.Second * 2)

	// Log a fatal message with additional arguments. This will terminate the process.
	logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}

logger/json

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a logger with Trace level and JSON formatter
	logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithFormatter(pterm.LogFormatterJSON)

	// Log a Trace level message with additional arguments
	logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))

	// Create a map of interesting stuff
	interestingStuff := map[string]any{
		"when were crayons invented":  "1903",
		"what is the meaning of life": 42,
		"is this interesting":         true,
	}

	// Log a Debug level message with arguments from the map
	logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))

	// Log Info, Warn, Error, and Fatal level messages with additional arguments
	logger.Info("That was actually interesting", logger.Args("such", "wow"))
	logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))
	logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))
	logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))
	logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}

logger/with-caller

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a logger with Trace level and caller information
	logger := pterm.DefaultLogger.WithLevel(pterm.LogLevelTrace).WithCaller()

	// Log a trace message with additional arguments
	logger.Trace("Doing not so important stuff", logger.Args("priority", "super low"))

	// Create a map of interesting stuff
	interestingStuff := map[string]any{
		"when were crayons invented":  "1903",
		"what is the meaning of life": 42,
		"is this interesting":         true,
	}

	// Log a debug message with arguments from a map
	logger.Debug("This might be interesting", logger.ArgsFromMap(interestingStuff))

	// Log an info message with additional arguments
	logger.Info("That was actually interesting", logger.Args("such", "wow"))

	// Log a warning message with additional arguments
	logger.Warn("Oh no, I see an error coming to us!", logger.Args("speed", 88, "measures", "mph"))

	// Log an error message with additional arguments
	logger.Error("Damn, here it is!", logger.Args("error", "something went wrong"))

	// Log an info message with additional arguments. PTerm will automatically wrap long logs.
	logger.Info("But what's really cool is, that you can print very long logs, and PTerm will automatically wrap them for you! Say goodbye to text, that has weird line breaks!", logger.Args("very", "long"))

	// Log a fatal message with additional arguments. This will terminate the process.
	logger.Fatal("Oh no, this process is getting killed!", logger.Args("fatal", true))
}

multiple-live-printers/demo

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Create a multi printer for managing multiple printers
	multi := pterm.DefaultMultiPrinter

	// Create two spinners with their own writers
	spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")
	spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")

	// Create five progress bars with their own writers and a total of 100
	pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
	pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
	pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
	pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
	pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")

	// Start the multi printer
	multi.Start()

	// Increment progress bars and spinners based on certain conditions
	for i := 1; i <= 100; i++ {
		pb1.Increment() // Increment progress bar 1 every iteration

		if i%2 == 0 {
			pb2.Add(3) // Add 3 to progress bar 2 every even iteration
		}

		if i%5 == 0 {
			pb3.Increment() // Increment progress bar 3 every 5th iteration
		}

		if i%10 == 0 {
			pb4.Increment() // Increment progress bar 4 every 10th iteration
		}

		if i%3 == 0 {
			pb5.Increment() // Increment progress bar 5 every 3rd iteration
		}

		if i%50 == 0 {
			spinner1.Success("Spinner 1 is done!") // Mark spinner 1 as successful every 50th iteration
		}

		if i%60 == 0 {
			spinner2.Fail("Spinner 2 failed!") // Mark spinner 2 as failed every 60th iteration
		}

		time.Sleep(time.Millisecond * 50) // Sleep for 50 milliseconds between each iteration
	}

	// Stop the multi printer
	multi.Stop()
}

panel/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define panels in a 2D grid system
	panels := pterm.Panels{
		{
			{Data: "This is the first panel"},
			{Data: pterm.DefaultHeader.Sprint("Hello, World!")},
			{Data: "This\npanel\ncontains\nmultiple\nlines"},
		},
		{
			{Data: pterm.Red("This is another\npanel line")},
			{Data: "This is the second panel\nwith a new line"},
		},
	}

	// Render the panels with a padding of 5
	_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}

paragraph/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Using the default paragraph printer to print a long text.
	// The text is split at the spaces, which is useful for continuous text of all kinds.
	// The line width can be manually adjusted if needed.
	pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
		"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")

	// Printing a line space for separation.
	pterm.Println()

	// Printing a long text without using the paragraph printer.
	// The default Println() function is used here, which does not provide intelligent splitting.
	pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}

paragraph/customized

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define a long text to be printed as a paragraph.
	longText := "This is a custom paragraph printer. As you can see, no words are separated, " +
		"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"

	// Print the long text as a paragraph with a custom maximal width of 60 characters.
	pterm.DefaultParagraph.WithMaxWidth(60).Println(longText)

	// Print a line space to separate the paragraph from the following text.
	pterm.Println()

	// Define another long text to be printed without a paragraph printer.
	longTextWithoutParagraph := "This text is written with the default Println() function. No intelligent splitting here." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam"

	// Print the long text without using a paragraph printer.
	pterm.Println(longTextWithoutParagraph)
}

prefix/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Enable debug messages in PTerm.
	pterm.EnableDebugMessages()

	// Print a debug message with PTerm.
	pterm.Debug.Println("Hello, World!")

	// Print an informational message with PTerm.
	pterm.Info.Println("Hello, World!")

	// Print a success message with PTerm.
	pterm.Success.Println("Hello, World!")

	// Print a warning message with PTerm.
	pterm.Warning.Println("Hello, World!")

	// Print an error message with PTerm. This will also display the filename and line number in the terminal.
	pterm.Error.Println("Errors show the filename and linenumber inside the terminal!")

	// Print an informational message with PTerm, with line number.
	// This demonstrates that other PrefixPrinters can also display line numbers.
	pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")

	// Temporarily set Fatal to false, so that the CI won't crash.
	// This will print a fatal message with PTerm, but won't terminate the program.
	pterm.Fatal.WithFatal(false).Println("Hello, World!")
}

progressbar/demo

Animation

SHOW SOURCE
package main

import (
	"strings"
	"time"

	"github.com/glados28/pterm"
)

// Slice of strings representing names of pseudo applications to be downloaded.
var fakeInstallList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

func main() {
	// Create a progressbar with the total steps equal to the number of items in fakeInstallList.
	// Set the initial title of the progressbar to "Downloading stuff".
	p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()

	// Loop over each item in the fakeInstallList.
	for i := 0; i < p.Total; i++ {
		// Simulate a slow download for the 7th item.
		if i == 6 {
			time.Sleep(time.Second * 3)
		}

		// Update the title of the progressbar with the current item being downloaded.
		p.UpdateTitle("Downloading " + fakeInstallList[i])

		// Print a success message for the current download. This will be printed above the progressbar.
		pterm.Success.Println("Downloading " + fakeInstallList[i])

		// Increment the progressbar by one to indicate progress.
		p.Increment()

		// Pause for 350 milliseconds to simulate the time taken for each download.
		time.Sleep(time.Millisecond * 350)
	}
}

progressbar/multiple

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Create a multi printer instance from the default one
	multi := pterm.DefaultMultiPrinter

	// Create five progress bars with a total of 100 units each, and assign each a new writer from the multi printer
	pb1, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 1")
	pb2, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 2")
	pb3, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 3")
	pb4, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 4")
	pb5, _ := pterm.DefaultProgressbar.WithTotal(100).WithWriter(multi.NewWriter()).Start("Progressbar 5")

	// Start the multi printer
	multi.Start()

	// Loop to increment progress bars based on certain conditions
	for i := 1; i <= 100; i++ {
		pb1.Increment() // Increment the first progress bar at each iteration

		if i%2 == 0 {
			pb2.Add(3) // Add 3 units to the second progress bar at every even iteration
		}

		if i%5 == 0 {
			pb3.Increment() // Increment the third progress bar at every fifth iteration
		}

		if i%10 == 0 {
			pb4.Increment() // Increment the fourth progress bar at every tenth iteration
		}

		if i%3 == 0 {
			pb5.Increment() // Increment the fifth progress bar at every third iteration
		}

		time.Sleep(time.Millisecond * 50) // Pause for 50 milliseconds at each iteration
	}

	// Stop the multi printer
	multi.Stop()
}

section/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Create a section with level one and print it.
	pterm.DefaultSection.Println("This is a section!")

	// Print an informational message.
	pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")

	// Create a section with level two and print it.
	pterm.DefaultSection.WithLevel(2).Println("This is another section!")

	// Print another informational message.
	pterm.Info.Println("And this is\nmore placeholder text")
}

slog/demo

Animation

SHOW SOURCE
package main

import (
	"log/slog"

	"github.com/glados28/pterm"
)

func main() {
	// Create a new slog handler with the default PTerm logger
	handler := pterm.NewSlogHandler(&pterm.DefaultLogger)

	// Create a new slog logger with the handler
	logger := slog.New(handler)

	// Log a debug message (won't show by default)
	logger.Debug("This is a debug message that won't show")

	// Change the log level to debug to enable debug messages
	pterm.DefaultLogger.Level = pterm.LogLevelDebug

	// Log a debug message (will show because debug level is enabled)
	logger.Debug("This is a debug message", "changedLevel", true)

	// Log an info message
	logger.Info("This is an info message")

	// Log a warning message
	logger.Warn("This is a warning message")

	// Log an error message
	logger.Error("This is an error message")
}

spinner/demo

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Create and start a fork of the default spinner.
	spinnerInfo, _ := pterm.DefaultSpinner.Start("Some informational action...")
	time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
	spinnerInfo.Info()          // Resolve spinner with error message.

	// Create and start a fork of the default spinner.
	spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
	time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
	spinnerSuccess.Success()    // Resolve spinner with success message.

	// Create and start a fork of the default spinner.
	spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
	time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
	spinnerWarning.Warning()    // Resolve spinner with warning message.

	// Create and start a fork of the default spinner.
	spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
	time.Sleep(time.Second * 2) // Simulate 3 seconds of processing something.
	spinnerFail.Fail()          // Resolve spinner with error message.

	// Create and start a fork of the default spinner.
	spinnerNochange, _ := pterm.DefaultSpinner.Start("Checking something important... (will result in no change)")
	// Replace the InfoPrinter with a custom "NOCHG" one
	spinnerNochange.InfoPrinter = &pterm.PrefixPrinter{
		MessageStyle: &pterm.Style{pterm.FgLightBlue},
		Prefix: pterm.Prefix{
			Style: &pterm.Style{pterm.FgBlack, pterm.BgLightBlue},
			Text:  " NOCHG ",
		},
	}
	time.Sleep(time.Second * 2)                     // Simulate 3 seconds of processing something.
	spinnerNochange.Info("No change were required") // Resolve spinner with error message.

	// Create and start a fork of the default spinner.
	spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
	time.Sleep(time.Second)                          // Simulate 2 seconds of processing something.
	spinnerLiveText.UpdateText("It's really much")   // Update spinner text.
	time.Sleep(time.Second)                          // Simulate 2 seconds of processing something.
	spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
	time.Sleep(time.Second)                          // Simulate 2 seconds of processing something.
	spinnerLiveText.Success("Finally!")              // Resolve spinner with success message.
}

spinner/multiple

Animation

SHOW SOURCE
package main

import (
	"time"

	"github.com/glados28/pterm"
)

func main() {
	// Create a multi printer. This allows multiple spinners to print simultaneously.
	multi := pterm.DefaultMultiPrinter

	// Create and start spinner 1 with a new writer from the multi printer.
	// The spinner will display the message "Spinner 1".
	spinner1, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 1")

	// Create and start spinner 2 with a new writer from the multi printer.
	// The spinner will display the message "Spinner 2".
	spinner2, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 2")

	// Create and start spinner 3 with a new writer from the multi printer.
	// The spinner will display the message "Spinner 3".
	spinner3, _ := pterm.DefaultSpinner.WithWriter(multi.NewWriter()).Start("Spinner 3")

	// Start the multi printer. This will start printing all the spinners.
	multi.Start()

	// Wait for 1 second.
	time.Sleep(time.Millisecond * 1000)

	// Stop spinner 1 with a success message.
	spinner1.Success("Spinner 1 is done!")

	// Wait for 750 milliseconds.
	time.Sleep(time.Millisecond * 750)

	// Stop spinner 2 with a failure message.
	spinner2.Fail("Spinner 2 failed!")

	// Wait for 500 milliseconds.
	time.Sleep(time.Millisecond * 500)

	// Stop spinner 3 with a warning message.
	spinner3.Warning("Spinner 3 has a warning!")

	// Stop the multi printer. This will stop printing all the spinners.
	multi.Stop()
}

style/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define a primary style with light cyan foreground, gray background, and bold text
	primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)

	// Define a secondary style with light green foreground, white background, and italic text
	secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)

	// Print "Hello, World!" with the primary style
	primary.Println("Hello, World!")

	// Print "Hello, World!" with the secondary style
	secondary.Println("Hello, World!")
}

table/demo

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the first table
	tableData1 := pterm.TableData{
		{"Firstname", "Lastname", "Email", "Note"},
		{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
		{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
		{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
		{"张", "小宝", "zhang@example.com", ""},
	}

	// Create a table with a header and the defined data, then render it
	pterm.DefaultTable.WithHasHeader().WithData(tableData1).Render()

	pterm.Println() // Blank line

	// Define the data for the second table
	tableData2 := pterm.TableData{
		{"Firstname", "Lastname", "Email"},
		{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
		{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
		{"Libby", "Camacho", "lobortis@semper.com"},
		{"张", "小宝", "zhang@example.com"},
	}

	// Create another table with a header and the defined data, then render it
	pterm.DefaultTable.WithHasHeader().WithData(tableData2).Render()
}

table/boxed

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the table.
	// Each inner slice represents a row in the table.
	// The first row is considered as the header of the table.
	tableData := pterm.TableData{
		{"Firstname", "Lastname", "Email", "Note"},
		{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
		{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
		{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
		{"张", "小宝", "zhang@example.com", ""},
	}

	// Create a table with the defined data.
	// The table has a header and is boxed.
	// Finally, render the table to print it.
	pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
}

table/multiple-lines

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the table.
	data := pterm.TableData{
		{"Firstname", "Lastname", "Email"},
		{"Paul\n\nNewline", "Dean", "augue@velitAliquam.co.uk"},
		{"Callie", "Mckay", "nunc.sed@est.com\nNewline"},
		{"Libby", "Camacho", "lobortis@semper.com"},
		{"张", "小宝", "zhang@example.com"},
	}

	// Create and render the table.
	// The options are chained in a single line for simplicity.
	// The table has a header, a row separator, and a header row separator.
	pterm.DefaultTable.WithHasHeader().WithRowSeparator("-").WithHeaderRowSeparator("-").WithData(data).Render()
}

table/right-alignment

Animation

SHOW SOURCE
package main

import "github.com/glados28/pterm"

func main() {
	// Define the data for the table.
	// Each inner slice represents a row in the table.
	// The first row is considered as the header.
	tableData := pterm.TableData{
		{"Firstname", "Lastname", "Email", "Note"},
		{"Paul", "Dean", "augue@velitAliquam.co.uk", ""},
		{"Callie", "Mckay", "nunc.sed@est.com", "这是一个测试, haha!"},
		{"Libby", "Camacho", "lobortis@semper.com", "just a test, hey!"},
		{"张", "小宝", "zhang@example.com", ""},
	}

	// Create a table with the defined data.
	// The table has a header and the text in the cells is right-aligned.
	// The Render() method is used to print the table to the console.
	pterm.DefaultTable.WithHasHeader().WithRightAlignment().WithData(tableData).Render()
}

theme/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"reflect"
	"time"
)

func main() {
	// Print an informational message about the default theme styles.
	pterm.Info.Println("These are the default theme styles.\nYou can modify them easily to your personal preference,\nor create new themes from scratch :)")

	// Print a blank line for better readability.
	pterm.Println()

	// Get the value and type of the default theme.
	v := reflect.ValueOf(pterm.ThemeDefault)
	typeOfS := v.Type()

	// Check if the type of the default theme is 'pterm.Theme'.
	if typeOfS == reflect.TypeOf(pterm.Theme{}) {
		// Iterate over each field in the default theme.
		for i := 0; i < v.NumField(); i++ {
			// Try to convert the field to 'pterm.Style'.
			field, ok := v.Field(i).Interface().(pterm.Style)
			if ok {
				// Print the field name using its own style.
				field.Println(typeOfS.Field(i).Name)
			}
			// Pause for a quarter of a second to make the output easier to read.
			time.Sleep(time.Millisecond * 250)
		}
	}
}

tree/demo

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
)

func main() {
	// Define a tree structure using pterm.TreeNode
	tree := pterm.TreeNode{
		// The top node of the tree
		Text: "Top node",
		// The children of the top node
		Children: []pterm.TreeNode{{
			// A child node
			Text: "Child node",
			// The children of the child node
			Children: []pterm.TreeNode{
				// Grandchildren nodes
				{Text: "Grandchild node"},
				{Text: "Grandchild node"},
				{Text: "Grandchild node"},
			},
		}},
	}

	// Render the tree with the defined structure as the root
	pterm.DefaultTree.WithRoot(tree).Render()
}

tree/from-leveled-list

Animation

SHOW SOURCE
package main

import (
	"github.com/glados28/pterm"
	"github.com/glados28/pterm/putils"
)

func main() {
	// Define a leveled list to represent the structure of the directories.
	leveledList := pterm.LeveledList{
		{Level: 0, Text: "C:"},
		{Level: 1, Text: "Users"},
		{Level: 1, Text: "Windows"},
		{Level: 1, Text: "Programs"},
		{Level: 1, Text: "Programs(x86)"},
		{Level: 1, Text: "dev"},
		{Level: 0, Text: "D:"},
		{Level: 0, Text: "E:"},
		{Level: 1, Text: "Movies"},
		{Level: 1, Text: "Music"},
		{Level: 2, Text: "LinkinPark"},
		{Level: 1, Text: "Games"},
		{Level: 2, Text: "Shooter"},
		{Level: 3, Text: "CallOfDuty"},
		{Level: 3, Text: "CS:GO"},
		{Level: 3, Text: "Battlefield"},
		{Level: 4, Text: "Battlefield 1"},
		{Level: 4, Text: "Battlefield 2"},
		{Level: 0, Text: "F:"},
		{Level: 1, Text: "dev"},
		{Level: 2, Text: "dops"},
		{Level: 2, Text: "PTerm"},
	}

	// Convert the leveled list into a tree structure.
	root := putils.TreeFromLeveledList(leveledList)
	root.Text = "Computer" // Set the root node text.

	// Render the tree structure using the default tree printer.
	pterm.DefaultTree.WithRoot(root).Render()
}


GitHub @pterm  ·  Author @MarvinJWendt | PTerm.sh

Documentation

Overview

Package pterm is a modern go module to beautify console output. It can be used without configuration, but if desired, everything can be customized down to the smallest detail.

Official docs are available at: https://docs.pterm.sh

View the animated examples here: https://github.com/glados28/pterm#-examples

Index

Constants

This section is empty.

Variables

View Source
var (
	// Red is an alias for FgRed.Sprint.
	Red = FgRed.Sprint
	// Cyan is an alias for FgCyan.Sprint.
	Cyan = FgCyan.Sprint
	// Gray is an alias for FgGray.Sprint.
	Gray = FgGray.Sprint
	// Blue is an alias for FgBlue.Sprint.
	Blue = FgBlue.Sprint
	// Black is an alias for FgBlack.Sprint.
	Black = FgBlack.Sprint
	// Green is an alias for FgGreen.Sprint.
	Green = FgGreen.Sprint
	// White is an alias for FgWhite.Sprint.
	White = FgWhite.Sprint
	// Yellow is an alias for FgYellow.Sprint.
	Yellow = FgYellow.Sprint
	// Magenta is an alias for FgMagenta.Sprint.
	Magenta = FgMagenta.Sprint

	// Normal is an alias for FgDefault.Sprint.
	Normal = FgDefault.Sprint

	// LightRed is a shortcut for FgLightRed.Sprint.
	LightRed = FgLightRed.Sprint
	// LightCyan is a shortcut for FgLightCyan.Sprint.
	LightCyan = FgLightCyan.Sprint
	// LightBlue is a shortcut for FgLightBlue.Sprint.
	LightBlue = FgLightBlue.Sprint
	// LightGreen is a shortcut for FgLightGreen.Sprint.
	LightGreen = FgLightGreen.Sprint
	// LightWhite is a shortcut for FgLightWhite.Sprint.
	LightWhite = FgLightWhite.Sprint
	// LightYellow is a shortcut for FgLightYellow.Sprint.
	LightYellow = FgLightYellow.Sprint
	// LightMagenta is a shortcut for FgLightMagenta.Sprint.
	LightMagenta = FgLightMagenta.Sprint
)
View Source
var (
	// ErrTerminalSizeNotDetectable - the terminal size can not be detected and the fallback values are used.
	ErrTerminalSizeNotDetectable = errors.New("terminal size could not be detected - using fallback value")

	// ErrHexCodeIsInvalid - the given HEX code is invalid.
	ErrHexCodeIsInvalid = errors.New("hex code is not valid")

	// ErrKeyWithoutValue - an odd number of arguments was passed to a pterm Logger's Args method.
	ErrKeyWithoutValue = "ERROR: key_without_value"
)
View Source
var (
	// Info returns a PrefixPrinter, which can be used to print text with an "info" Prefix.
	Info = PrefixPrinter{
		MessageStyle: &ThemeDefault.InfoMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.InfoPrefixStyle,
			Text:  "INFO",
		},
	}

	// Warning returns a PrefixPrinter, which can be used to print text with a "warning" Prefix.
	Warning = PrefixPrinter{
		MessageStyle: &ThemeDefault.WarningMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.WarningPrefixStyle,
			Text:  "WARNING",
		},
	}

	// Success returns a PrefixPrinter, which can be used to print text with a "success" Prefix.
	Success = PrefixPrinter{
		MessageStyle: &ThemeDefault.SuccessMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.SuccessPrefixStyle,
			Text:  "SUCCESS",
		},
	}

	// Error returns a PrefixPrinter, which can be used to print text with an "error" Prefix.
	Error = PrefixPrinter{
		MessageStyle: &ThemeDefault.ErrorMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.ErrorPrefixStyle,
			Text:  " ERROR ",
		},
	}

	// Fatal returns a PrefixPrinter, which can be used to print text with an "fatal" Prefix.
	// NOTICE: Fatal terminates the application immediately!
	Fatal = PrefixPrinter{
		MessageStyle: &ThemeDefault.FatalMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.FatalPrefixStyle,
			Text:  " FATAL ",
		},
		Fatal: true,
	}

	// Debug Prints debug messages. By default it will only print if PrintDebugMessages is true.
	// You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.
	Debug = PrefixPrinter{
		MessageStyle: &ThemeDefault.DebugMessageStyle,
		Prefix: Prefix{
			Text:  " DEBUG ",
			Style: &ThemeDefault.DebugPrefixStyle,
		},
		Debugger: true,
	}

	// Description returns a PrefixPrinter, which can be used to print text with a "description" Prefix.
	Description = PrefixPrinter{
		MessageStyle: &ThemeDefault.DescriptionMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.DescriptionPrefixStyle,
			Text:  "Description",
		},
	}
)
View Source
var (
	// Output completely disables output from pterm if set to false. Can be used in CLI application quiet mode.
	Output = true

	// PrintDebugMessages sets if messages printed by the DebugPrinter should be printed.
	PrintDebugMessages = false

	// RawOutput is set to true if pterm.DisableStyling() was called.
	// The variable indicates that PTerm will not add additional styling to text.
	// Use pterm.DisableStyling() or pterm.EnableStyling() to change this variable.
	// Changing this variable directly, will disable or enable the output of colored text.
	RawOutput = false
)
View Source
var ActiveProgressBarPrinters []*ProgressbarPrinter

ActiveProgressBarPrinters contains all running ProgressbarPrinters. Generally, there should only be one active ProgressbarPrinter at a time.

View Source
var DefaultArea = AreaPrinter{}

DefaultArea is the default area printer.

View Source
var (
	// DefaultBarChart is the default BarChartPrinter.
	DefaultBarChart = BarChartPrinter{
		Horizontal:             false,
		VerticalBarCharacter:   "██",
		HorizontalBarCharacter: "█",

		Height: GetTerminalHeight() * 2 / 3,
		Width:  GetTerminalWidth() * 2 / 3,
	}
)
View Source
var (
	// DefaultBasicText returns a default BasicTextPrinter, which can be used to print text as is.
	// No default style is present for BasicTextPrinter.
	DefaultBasicText = BasicTextPrinter{}
)
View Source
var DefaultBigText = BigTextPrinter{
	BigCharacters: map[string]string{
		"a": ` █████  
██   ██ 
███████ 
██   ██ 
██   ██ `,
		"A": ` █████  
██   ██ 
███████ 
██   ██ 
██   ██ `,
		"b": `██████  
██   ██ 
██████  
██   ██ 
██████`,
		"B": `██████  
██   ██ 
██████  
██   ██ 
██████`,
		"c": ` ██████ 
██      
██      
██      
 ██████`,
		"C": ` ██████ 
██      
██      
██      
 ██████`,
		"d": `██████  
██   ██ 
██   ██ 
██   ██ 
██████ `,
		"D": `██████  
██   ██ 
██   ██ 
██   ██ 
██████ `,
		"e": `███████ 
██      
█████   
██      
███████`,
		"E": `███████ 
██      
█████   
██      
███████`,
		"f": `███████ 
██      
█████   
██      
██     `,
		"F": `███████ 
██      
█████   
██      
██     `,
		"g": ` ██████  
██       
██   ███ 
██    ██ 
 ██████  `,
		"G": ` ██████  
██       
██   ███ 
██    ██ 
 ██████  `,
		"h": `██   ██ 
██   ██ 
███████ 
██   ██ 
██   ██ `,
		"H": `██   ██ 
██   ██ 
███████ 
██   ██ 
██   ██ `,
		"i": `██ 
██ 
██ 
██ 
██`,
		"I": `██ 
██ 
██ 
██ 
██`,
		"j": `     ██ 
     ██ 
     ██ 
██   ██ 
 █████ `,
		"J": `     ██ 
     ██ 
     ██ 
██   ██ 
 █████ `,
		"k": `██   ██ 
██  ██  
█████   
██  ██  
██   ██`,
		"K": `██   ██ 
██  ██  
█████   
██  ██  
██   ██`,
		"l": `██      
██      
██      
██      
███████ `,
		"L": `██      
██      
██      
██      
███████ `,
		"m": `███    ███ 
████  ████ 
██ ████ ██ 
██  ██  ██ 
██      ██`,
		"M": `███    ███ 
████  ████ 
██ ████ ██ 
██  ██  ██ 
██      ██`,
		"n": `███    ██ 
████   ██ 
██ ██  ██ 
██  ██ ██ 
██   ████`,
		"N": `███    ██ 
████   ██ 
██ ██  ██ 
██  ██ ██ 
██   ████`,
		"o": ` ██████  
██    ██ 
██    ██ 
██    ██ 
 ██████  `,
		"O": ` ██████  
██    ██ 
██    ██ 
██    ██ 
 ██████  `,
		"p": `██████  
██   ██ 
██████  
██      
██     `,
		"P": `██████  
██   ██ 
██████  
██      
██     `,
		"q": ` ██████  
██    ██ 
██    ██ 
██ ▄▄ ██ 
 ██████  
    ▀▀   `,
		"Q": ` ██████  
██    ██ 
██    ██ 
██ ▄▄ ██ 
 ██████  
    ▀▀   `,
		"r": `██████  
██   ██ 
██████  
██   ██ 
██   ██`,
		"R": `██████  
██   ██ 
██████  
██   ██ 
██   ██`,
		"s": `███████ 
██      
███████ 
     ██ 
███████`,
		"S": `███████ 
██      
███████ 
     ██ 
███████`,
		"t": `████████ 
   ██    
   ██    
   ██    
   ██    `,
		"T": `████████ 
   ██    
   ██    
   ██    
   ██    `,
		"u": `██    ██ 
██    ██ 
██    ██ 
██    ██ 
 ██████ `,
		"U": `██    ██ 
██    ██ 
██    ██ 
██    ██ 
 ██████ `,
		"v": `██    ██ 
██    ██ 
██    ██ 
 ██  ██  
  ████   `,
		"V": `██    ██ 
██    ██ 
██    ██ 
 ██  ██  
  ████   `,
		"w": `██     ██ 
██     ██ 
██  █  ██ 
██ ███ ██ 
 ███ ███ `,
		"W": `██     ██ 
██     ██ 
██  █  ██ 
██ ███ ██ 
 ███ ███ `,
		"x": `██   ██ 
 ██ ██  
  ███   
 ██ ██  
██   ██ `,
		"X": `██   ██ 
 ██ ██  
  ███   
 ██ ██  
██   ██ `,
		"y": `██    ██ 
 ██  ██  
  ████   
   ██    
   ██   `,
		"Y": `██    ██ 
 ██  ██  
  ████   
   ██    
   ██   `,
		"z": `███████ 
   ███  
  ███   
 ███    
███████`,
		"Z": `███████ 
   ███  
  ███   
 ███    
███████`,
		"0": ` ██████  
██  ████ 
██ ██ ██ 
████  ██ 
 ██████ `,
		"1": ` ██ 
███ 
 ██ 
 ██ 
 ██ `,
		"2": `██████  
     ██ 
 █████  
██      
███████ `,
		"3": `██████  
     ██ 
 █████  
     ██ 
██████ `,
		"4": `██   ██ 
██   ██ 
███████ 
     ██ 
     ██ `,
		"5": `███████ 
██      
███████ 
     ██ 
███████`,
		"6": ` ██████  
██       
███████  
██    ██ 
 ██████ `,
		"7": `███████ 
     ██ 
    ██  
   ██   
   ██`,
		"8": ` █████  
██   ██ 
 █████  
██   ██ 
 █████ `,
		"9": ` █████  
██   ██ 
 ██████ 
     ██ 
 █████ `,
		" ": "    ",
		"!": `██ 
██ 
██ 
   
██ `,
		"$": `▄▄███▄▄·
██      
███████ 
     ██ 
███████ 
  ▀▀▀  `,
		"%": `██  ██ 
   ██  
  ██   
 ██    
██  ██`,
		"/": `    ██ 
   ██  
  ██   
 ██    
██   `,
		"(": ` ██ 
██  
██  
██  
 ██ `,
		")": `██  
 ██ 
 ██ 
 ██ 
██  `,
		"?": `██████  
     ██ 
  ▄███  
  ▀▀    
  ██   `,
		"[": `███ 
██  
██  
██  
███`,
		"]": `███ 
 ██ 
 ██ 
 ██ 
███ `,
		".": `   
   
   
   
██`,
		",": `   
   
   
   
▄█`,
		"-": `      
      
█████ 
      
      
     `,
		"<": `  ██ 
 ██  
██   
 ██  
  ██ `,
		">": `██   
 ██  
  ██ 
 ██  
██ `,
		"*": `      
▄ ██ ▄
 ████ 
▀ ██ ▀
     `,
		"#": ` ██  ██  
████████ 
 ██  ██  
████████ 
 ██  ██ `,
		"_": `        
        
        
        
███████ `,
		":": `   
██ 
   
   
██ `,
		"°": ` ████  
██  ██ 
 ████  
       
      `,
	},
}

DefaultBigText contains default values for BigTextPrinter.

View Source
var DefaultBox = BoxPrinter{
	VerticalString:          "|",
	TopRightCornerString:    "└",
	TopLeftCornerString:     "┘",
	BottomLeftCornerString:  "┐",
	BottomRightCornerString: "┌",
	HorizontalString:        "─",
	BoxStyle:                &ThemeDefault.BoxStyle,
	TextStyle:               &ThemeDefault.BoxTextStyle,
	RightPadding:            1,
	LeftPadding:             1,
	TopPadding:              0,
	BottomPadding:           0,
	TitleTopLeft:            true,
}

DefaultBox is the default BoxPrinter.

View Source
var DefaultBulletList = BulletListPrinter{
	Bullet:      "•",
	TextStyle:   &ThemeDefault.BulletListTextStyle,
	BulletStyle: &ThemeDefault.BulletListBulletStyle,
}

DefaultBulletList contains standards, which can be used to print a BulletListPrinter.

View Source
var DefaultCenter = CenterPrinter{
	CenterEachLineSeparately: false,
}

DefaultCenter is the default CenterPrinter.

View Source
var (
	// DefaultHeader returns the printer for a default header text.
	// Defaults to LightWhite, Bold Text and a Gray DefaultHeader background.
	DefaultHeader = HeaderPrinter{
		TextStyle:       &ThemeDefault.HeaderTextStyle,
		BackgroundStyle: &ThemeDefault.HeaderBackgroundStyle,
		Margin:          5,
	}
)
View Source
var DefaultHeatmap = HeatmapPrinter{
	AxisStyle:                  &ThemeDefault.HeatmapHeaderStyle,
	SeparatorStyle:             &ThemeDefault.HeatmapSeparatorStyle,
	VerticalSeparator:          "│",
	TopRightCornerSeparator:    "└",
	TopLeftCornerSeparator:     "┘",
	BottomLeftCornerSeparator:  "┐",
	BottomRightCornerSeparator: "┌",
	HorizontalSeparator:        "─",
	TSeparator:                 "┬",
	TReverseSeparator:          "┴",
	LSeparator:                 "├",
	LReverseSeparator:          "┤",
	TCrossSeparator:            "┼",
	LegendLabel:                "Legend",
	Boxed:                      true,
	Grid:                       true,
	Legend:                     true,
	TextRGB:                    RGB{0, 0, 0, false},
	RGBRange:                   []RGB{{R: 255, G: 0, B: 0, Background: true}, {R: 255, G: 165, B: 0, Background: true}, {R: 0, G: 255, B: 0, Background: true}},
	TextColor:                  FgBlack,
	Colors:                     []Color{BgRed, BgLightRed, BgYellow, BgLightYellow, BgLightGreen, BgGreen},

	EnableRGB: false,
}

DefaultHeatmap contains standards, which can be used to print a HeatmapPrinter.

View Source
var DefaultInteractiveConfirm = InteractiveConfirmPrinter{
	DefaultValue: false,
	DefaultText:  "Please confirm",
	TextStyle:    &ThemeDefault.PrimaryStyle,
	ConfirmText:  "Yes",
	ConfirmStyle: &ThemeDefault.SuccessMessageStyle,
	RejectText:   "No",
	RejectStyle:  &ThemeDefault.ErrorMessageStyle,
	SuffixStyle:  &ThemeDefault.SecondaryStyle,
	Delimiter:    ": ",
}

DefaultInteractiveConfirm is the default InteractiveConfirm printer. Pressing "y" will return true, "n" will return false. Pressing enter without typing "y" or "n" will return the configured default value (by default set to "no").

View Source
var DefaultInteractiveContinue = InteractiveContinuePrinter{
	DefaultValueIndex: 0,
	DefaultText:       "Do you want to continue",
	TextStyle:         &ThemeDefault.PrimaryStyle,
	Options:           []string{"yes", "no", "all", "cancel"},
	OptionsStyle:      &ThemeDefault.SuccessMessageStyle,
	SuffixStyle:       &ThemeDefault.SecondaryStyle,
	Delimiter:         ": ",
}

DefaultInteractiveContinue is the default InteractiveContinue printer. Pressing "y" will return yes, "n" will return no, "a" returns all and "s" returns stop. Pressing enter without typing any letter will return the configured default value (by default set to "yes", the fisrt option).

View Source
var (
	// DefaultInteractiveMultiselect is the default InteractiveMultiselect printer.
	DefaultInteractiveMultiselect = InteractiveMultiselectPrinter{
		TextStyle:      &ThemeDefault.PrimaryStyle,
		DefaultText:    "Please select your options",
		Options:        []string{},
		OptionStyle:    &ThemeDefault.DefaultText,
		DefaultOptions: []string{},
		MaxHeight:      5,
		Selector:       ">",
		SelectorStyle:  &ThemeDefault.SecondaryStyle,
		Filter:         true,
		KeySelect:      keys.Enter,
		KeyConfirm:     keys.Tab,
		Checkmark:      &ThemeDefault.Checkmark,
	}
)
View Source
var (
	// DefaultInteractiveSelect is the default InteractiveSelect printer.
	DefaultInteractiveSelect = InteractiveSelectPrinter{
		TextStyle:     &ThemeDefault.PrimaryStyle,
		DefaultText:   "Please select an option",
		Options:       []string{},
		OptionStyle:   &ThemeDefault.DefaultText,
		DefaultOption: "",
		MaxHeight:     5,
		Selector:      ">",
		SelectorStyle: &ThemeDefault.SecondaryStyle,
		Filter:        true,
		ErrorOnTab:    false,
	}
)
View Source
var DefaultInteractiveTextInput = InteractiveTextInputPrinter{
	DefaultText: "Input text",
	Delimiter:   ": ",
	TextStyle:   &ThemeDefault.PrimaryStyle,
	Mask:        "",
	InputColor:  FgGray,
	ErrorOnTab:  false,
	OnUpDown:    nil,
}

DefaultInteractiveTextInput is the default InteractiveTextInput printer.

View Source
var DefaultLogger = Logger{
	Formatter:  LogFormatterColorful,
	Writer:     os.Stdout,
	Level:      LogLevelInfo,
	ShowTime:   true,
	TimeFormat: "2006-01-02 15:04:05",
	MaxWidth:   80,
	KeyStyles: map[string]Style{
		"error":  *NewStyle(FgRed, Bold),
		"err":    *NewStyle(FgRed, Bold),
		"caller": *NewStyle(FgGray, Bold),
	},
}

DefaultLogger is the default logger.

View Source
var DefaultMultiPrinter = MultiPrinter{

	Writer:      os.Stdout,
	UpdateDelay: time.Millisecond * 200,
	// contains filtered or unexported fields
}
View Source
var DefaultPanel = PanelPrinter{
	Padding: 1,
}

DefaultPanel is the default PanelPrinter.

View Source
var DefaultParagraph = ParagraphPrinter{
	MaxWidth: GetTerminalWidth(),
}

DefaultParagraph contains the default values for a ParagraphPrinter.

View Source
var DefaultProgressbar = ProgressbarPrinter{
	Total:                     100,
	BarCharacter:              "█",
	LastCharacter:             "█",
	ElapsedTimeRoundingFactor: time.Second,
	BarStyle:                  &ThemeDefault.ProgressbarBarStyle,
	TitleStyle:                &ThemeDefault.ProgressbarTitleStyle,
	ShowTitle:                 true,
	ShowCount:                 true,
	ShowPercentage:            true,
	ShowElapsedTime:           true,
	BarFiller:                 Gray("█"),
	MaxWidth:                  80,
	Writer:                    os.Stdout,
}

DefaultProgressbar is the default ProgressbarPrinter.

View Source
var DefaultSection = SectionPrinter{
	Style:           &ThemeDefault.SectionStyle,
	Level:           1,
	TopPadding:      1,
	BottomPadding:   1,
	IndentCharacter: "#",
}

DefaultSection is the default section printer.

View Source
var DefaultSpinner = SpinnerPrinter{
	Sequence:            []string{"▀ ", " ▀", " ▄", "▄ "},
	Style:               &ThemeDefault.SpinnerStyle,
	Delay:               time.Millisecond * 200,
	ShowTimer:           true,
	TimerRoundingFactor: time.Second,
	TimerStyle:          &ThemeDefault.TimerStyle,
	MessageStyle:        &ThemeDefault.SpinnerTextStyle,
	InfoPrinter:         &Info,
	SuccessPrinter:      &Success,
	FailPrinter:         &Error,
	WarningPrinter:      &Warning,
}

DefaultSpinner is the default SpinnerPrinter.

View Source
var DefaultTable = TablePrinter{
	Style:                   &ThemeDefault.TableStyle,
	HeaderStyle:             &ThemeDefault.TableHeaderStyle,
	HeaderRowSeparator:      "",
	HeaderRowSeparatorStyle: &ThemeDefault.TableSeparatorStyle,
	Separator:               " | ",
	SeparatorStyle:          &ThemeDefault.TableSeparatorStyle,
	RowSeparator:            "",
	RowSeparatorStyle:       &ThemeDefault.TableSeparatorStyle,
	LeftAlignment:           true,
	RightAlignment:          false,
}

DefaultTable contains standards, which can be used to print a TablePrinter.

View Source
var DefaultTree = TreePrinter{
	TreeStyle:            &ThemeDefault.TreeStyle,
	TextStyle:            &ThemeDefault.TreeTextStyle,
	TopRightCornerString: "└",
	HorizontalString:     "─",
	TopRightDownString:   "├",
	VerticalString:       "│",
	RightDownLeftString:  "┬",
	Indent:               2,
}

DefaultTree contains standards, which can be used to render a TreePrinter.

View Source
var EscapePressed = tEscapePressed{}
View Source
var FallbackTerminalHeight = 10

FallbackTerminalHeight is the value used for GetTerminalHeight, if the actual height can not be detected You can override that value if necessary.

View Source
var FallbackTerminalWidth = 80

FallbackTerminalWidth is the value used for GetTerminalWidth, if the actual width can not be detected You can override that value if necessary.

View Source
var (
	// GrayBoxStyle wraps text in a gray box.
	GrayBoxStyle = NewStyle(BgGray, FgLightWhite)
)
View Source
var PrintColor = true

PrintColor is false if PTerm should not print colored output.

View Source
var TabPressed = tTabPressed{}
View Source
var (
	// ThemeDefault is the default theme used by PTerm.
	// If this variable is overwritten, the new value is used as default theme.
	ThemeDefault = Theme{
		DefaultText:             Style{FgDefault, BgDefault},
		PrimaryStyle:            Style{FgLightCyan},
		SecondaryStyle:          Style{FgLightMagenta},
		HighlightStyle:          Style{Bold, FgYellow},
		InfoMessageStyle:        Style{FgLightCyan},
		InfoPrefixStyle:         Style{FgBlack, BgCyan},
		SuccessMessageStyle:     Style{FgGreen},
		SuccessPrefixStyle:      Style{FgBlack, BgGreen},
		WarningMessageStyle:     Style{FgYellow},
		WarningPrefixStyle:      Style{FgBlack, BgYellow},
		ErrorMessageStyle:       Style{FgLightRed},
		ErrorPrefixStyle:        Style{FgBlack, BgLightRed},
		FatalMessageStyle:       Style{FgLightRed},
		FatalPrefixStyle:        Style{FgBlack, BgLightRed},
		DescriptionMessageStyle: Style{FgDefault},
		DescriptionPrefixStyle:  Style{FgLightWhite, BgDarkGray},
		ScopeStyle:              Style{FgGray},
		ProgressbarBarStyle:     Style{FgCyan},
		ProgressbarTitleStyle:   Style{FgLightCyan},
		HeaderTextStyle:         Style{FgLightWhite, Bold},
		HeaderBackgroundStyle:   Style{BgGray},
		SpinnerStyle:            Style{FgLightCyan},
		SpinnerTextStyle:        Style{FgLightWhite},
		TableStyle:              Style{FgDefault},
		TableHeaderStyle:        Style{FgLightCyan},
		TableSeparatorStyle:     Style{FgGray},
		HeatmapStyle:            Style{FgDefault},
		HeatmapHeaderStyle:      Style{FgLightCyan},
		HeatmapSeparatorStyle:   Style{FgDefault},
		SectionStyle:            Style{Bold, FgYellow},
		BulletListTextStyle:     Style{FgDefault},
		BulletListBulletStyle:   Style{FgGray},
		TreeStyle:               Style{FgGray},
		TreeTextStyle:           Style{FgDefault},
		LetterStyle:             Style{FgDefault},
		DebugMessageStyle:       Style{FgGray},
		DebugPrefixStyle:        Style{FgBlack, BgGray},
		BoxStyle:                Style{FgDefault},
		BoxTextStyle:            Style{FgDefault},
		BarLabelStyle:           Style{FgLightCyan},
		BarStyle:                Style{FgCyan},
		TimerStyle:              Style{FgGray},
		Checkmark: Checkmark{
			Checked:   Green("✓"),
			Unchecked: Red("✗"),
		},
	}
)

Functions

func DisableColor

func DisableColor()

DisableColor disables colors.

func DisableDebugMessages

func DisableDebugMessages()

DisableDebugMessages disables the output of debug printers.

func DisableOutput

func DisableOutput()

DisableOutput disables the output of PTerm.

func DisableStyling

func DisableStyling()

DisableStyling sets PTerm to RawOutput mode and disables all of PTerms styling. You can use this to print to text files etc. This also calls DisableColor.

func EnableColor

func EnableColor()

EnableColor enables colors.

func EnableDebugMessages

func EnableDebugMessages()

EnableDebugMessages enables the output of debug printers.

func EnableOutput

func EnableOutput()

EnableOutput enables the output of PTerm.

func EnableStyling

func EnableStyling()

EnableStyling enables the default PTerm styling. This also calls EnableColor.

func Fprint

func Fprint(writer io.Writer, a ...interface{})

Fprint formats using the default formats for its operands and writes to w. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func Fprintln

func Fprintln(writer io.Writer, a ...interface{})

Fprintln formats using the default formats for its operands and writes to w. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Fprinto

func Fprinto(w io.Writer, a ...interface{})

Fprinto prints Printo to a custom writer.

func GetTerminalHeight

func GetTerminalHeight() int

GetTerminalHeight returns the terminal height of the active terminal.

func GetTerminalSize

func GetTerminalSize() (width, height int, err error)

GetTerminalSize returns the width and the height of the active terminal.

func GetTerminalWidth

func GetTerminalWidth() int

GetTerminalWidth returns the terminal width of the active terminal.

func Print

func Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func PrintOnError

func PrintOnError(a ...interface{})

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func PrintOnErrorf

func PrintOnErrorf(format string, a ...interface{})

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func Printf

func Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func Printfln

func Printfln(format string, a ...interface{})

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Println

func Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Printo

func Printo(a ...interface{})

Printo overrides the current line in a terminal. If the current line is empty, the text will be printed like with pterm.Print. Example:

pterm.Printo("Hello, World")
time.Sleep(time.Second)
pterm.Printo("Hello, Earth!")

func RecalculateTerminalSize

func RecalculateTerminalSize()

RecalculateTerminalSize updates already initialized terminal dimensions. Has to be called after a terminal resize to guarantee proper rendering. Applies only to new instances.

func RemoveColorFromString

func RemoveColorFromString(a ...interface{}) string

RemoveColorFromString removes color codes from a string.

func SetDefaultOutput

func SetDefaultOutput(w io.Writer)

SetDefaultOutput sets the default output of pterm.

func SetForcedTerminalSize

func SetForcedTerminalSize(width int, height int)

setForcedTerminalSize turns off terminal size autodetection. Usuful for unified tests.

func Sprint

func Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func Sprintf

func Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func Sprintfln

func Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func Sprintln

func Sprintln(a ...interface{}) string

Sprintln returns what Println would print to the terminal.

func Sprinto

func Sprinto(a ...interface{}) string

Sprinto returns what Printo would print.

Types

type AreaPrinter

type AreaPrinter struct {
	RemoveWhenDone bool
	Fullscreen     bool
	Center         bool
	// contains filtered or unexported fields
}

AreaPrinter prints an area which can be updated easily. use this printer for live output like charts, algorithm visualizations, simulations and even games.

func (*AreaPrinter) Clear

func (p *AreaPrinter) Clear()

Clear is a Wrapper function that clears the content of the Area moves the cursor to the bottom of the terminal, clears n lines upwards from the current position and moves the cursor again.

func (*AreaPrinter) GenericStart

func (p *AreaPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (*AreaPrinter) GenericStop

func (p *AreaPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (*AreaPrinter) GetContent

func (p *AreaPrinter) GetContent() string

GetContent returns the current area content.

func (*AreaPrinter) SetWriter

func (p *AreaPrinter) SetWriter(writer io.Writer)

SetWriter sets the writer for the AreaPrinter.

func (*AreaPrinter) Start

func (p *AreaPrinter) Start(text ...interface{}) (*AreaPrinter, error)

Start the AreaPrinter.

func (*AreaPrinter) Stop

func (p *AreaPrinter) Stop() error

Stop terminates the AreaPrinter immediately. The AreaPrinter will not resolve into anything.

func (*AreaPrinter) Update

func (p *AreaPrinter) Update(text ...interface{})

Update overwrites the content of the AreaPrinter. Can be used live.

func (AreaPrinter) WithCenter

func (p AreaPrinter) WithCenter(b ...bool) *AreaPrinter

WithCenter centers the AreaPrinter content to the terminal.

func (AreaPrinter) WithFullscreen

func (p AreaPrinter) WithFullscreen(b ...bool) *AreaPrinter

WithFullscreen sets the AreaPrinter height the same height as the terminal, making it fullscreen.

func (AreaPrinter) WithRemoveWhenDone

func (p AreaPrinter) WithRemoveWhenDone(b ...bool) *AreaPrinter

WithRemoveWhenDone removes the AreaPrinter content after it is stopped.

type Bar

type Bar struct {
	Label      string
	Value      int
	Style      *Style
	LabelStyle *Style
}

Bar is used in bar charts.

func (Bar) WithLabel

func (p Bar) WithLabel(s string) *Bar

WithLabel returns a new Bar with a specific option.

func (Bar) WithLabelStyle

func (p Bar) WithLabelStyle(style *Style) *Bar

WithLabelStyle returns a new Bar with a specific option.

func (Bar) WithStyle

func (p Bar) WithStyle(style *Style) *Bar

WithStyle returns a new Bar with a specific option.

func (Bar) WithValue

func (p Bar) WithValue(value int) *Bar

WithValue returns a new Bar with a specific option.

type BarChartPrinter

type BarChartPrinter struct {
	Writer     io.Writer
	Bars       Bars
	Horizontal bool
	ShowValue  bool
	// Height sets the maximum height of a vertical bar chart.
	// The default is calculated to fit into the terminal.
	// Ignored if Horizontal is set to true.
	Height int
	// Width sets the maximum width of a horizontal bar chart.
	// The default is calculated to fit into the terminal.
	// Ignored if Horizontal is set to false.
	Width                  int
	VerticalBarCharacter   string
	HorizontalBarCharacter string
}

BarChartPrinter is used to print bar charts.

func (BarChartPrinter) Render

func (p BarChartPrinter) Render() error

Render prints the Template to the terminal.

func (BarChartPrinter) Srender

func (p BarChartPrinter) Srender() (string, error)

Srender renders the BarChart as a string.

func (BarChartPrinter) WithBars

func (p BarChartPrinter) WithBars(bars Bars) *BarChartPrinter

WithBars returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHeight

func (p BarChartPrinter) WithHeight(value int) *BarChartPrinter

WithHeight returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHorizontal

func (p BarChartPrinter) WithHorizontal(b ...bool) *BarChartPrinter

WithHorizontal returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHorizontalBarCharacter

func (p BarChartPrinter) WithHorizontalBarCharacter(char string) *BarChartPrinter

WithHorizontalBarCharacter returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithShowValue

func (p BarChartPrinter) WithShowValue(b ...bool) *BarChartPrinter

WithShowValue returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithVerticalBarCharacter

func (p BarChartPrinter) WithVerticalBarCharacter(char string) *BarChartPrinter

WithVerticalBarCharacter returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithWidth

func (p BarChartPrinter) WithWidth(value int) *BarChartPrinter

WithWidth returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithWriter

func (p BarChartPrinter) WithWriter(writer io.Writer) *BarChartPrinter

WithWriter sets the custom Writer.

type Bars

type Bars []Bar

Bars is used to display multiple Bar.

type BasicTextPrinter

type BasicTextPrinter struct {
	Style  *Style
	Writer io.Writer
}

BasicTextPrinter is the printer used to print the input as-is or as specified by user formatting.

func (*BasicTextPrinter) Print

func (p *BasicTextPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to provided writer. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*BasicTextPrinter) PrintOnError

func (p *BasicTextPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*BasicTextPrinter) PrintOnErrorf

func (p *BasicTextPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*BasicTextPrinter) Printf

func (p *BasicTextPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to provided writer. It returns the number of bytes written and any write error encountered.

func (*BasicTextPrinter) Printfln

func (p *BasicTextPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to provided writer. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*BasicTextPrinter) Println

func (p *BasicTextPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to provided writer. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (BasicTextPrinter) Sprint

func (p BasicTextPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (BasicTextPrinter) Sprintf

func (p BasicTextPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (BasicTextPrinter) Sprintfln

func (p BasicTextPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BasicTextPrinter) Sprintln

func (p BasicTextPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BasicTextPrinter) WithStyle

func (p BasicTextPrinter) WithStyle(style *Style) *BasicTextPrinter

WithStyle adds a style to the printer.

func (BasicTextPrinter) WithWriter

func (p BasicTextPrinter) WithWriter(writer io.Writer) *BasicTextPrinter

type BigTextPrinter

type BigTextPrinter struct {
	// BigCharacters holds the map from a normal character to it's big version.
	BigCharacters map[string]string
	Letters       Letters
	Writer        io.Writer
}

BigTextPrinter renders big text. You can use this as title screen for your application.

func (BigTextPrinter) Render

func (p BigTextPrinter) Render() error

Render prints the BigText to the terminal.

func (BigTextPrinter) Srender

func (p BigTextPrinter) Srender() (string, error)

Srender renders the BigText as a string.

func (BigTextPrinter) WithBigCharacters

func (p BigTextPrinter) WithBigCharacters(chars map[string]string) *BigTextPrinter

WithBigCharacters returns a new BigTextPrinter with specific BigCharacters.

func (BigTextPrinter) WithLetters

func (p BigTextPrinter) WithLetters(letters ...Letters) *BigTextPrinter

WithLetters returns a new BigTextPrinter with specific Letters

func (BigTextPrinter) WithWriter

func (p BigTextPrinter) WithWriter(writer io.Writer) *BigTextPrinter

WithWriter sets the custom Writer.

type BoxPrinter

type BoxPrinter struct {
	Title                   string
	TitleTopLeft            bool
	TitleTopRight           bool
	TitleTopCenter          bool
	TitleBottomLeft         bool
	TitleBottomRight        bool
	TitleBottomCenter       bool
	TextStyle               *Style
	VerticalString          string
	BoxStyle                *Style
	HorizontalString        string
	TopRightCornerString    string
	TopLeftCornerString     string
	BottomLeftCornerString  string
	BottomRightCornerString string
	TopPadding              int
	BottomPadding           int
	RightPadding            int
	LeftPadding             int
	Writer                  io.Writer
}

BoxPrinter is able to render a box around printables.

func (BoxPrinter) Print

func (p BoxPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) PrintOnError

func (p BoxPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (BoxPrinter) PrintOnErrorf

func (p BoxPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (BoxPrinter) Printf

func (p BoxPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Printfln

func (p BoxPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Println

func (p BoxPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Sprint

func (p BoxPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (BoxPrinter) Sprintf

func (p BoxPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (BoxPrinter) Sprintfln

func (p BoxPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BoxPrinter) Sprintln

func (p BoxPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BoxPrinter) WithBottomLeftCornerString

func (p BoxPrinter) WithBottomLeftCornerString(str string) *BoxPrinter

WithBottomLeftCornerString returns a new box with a specific BottomLeftCornerString.

func (BoxPrinter) WithBottomPadding

func (p BoxPrinter) WithBottomPadding(padding int) *BoxPrinter

WithBottomPadding returns a new box with a specific BottomPadding.

func (BoxPrinter) WithBottomRightCornerString

func (p BoxPrinter) WithBottomRightCornerString(str string) *BoxPrinter

WithBottomRightCornerString returns a new box with a specific BottomRightCornerString.

func (BoxPrinter) WithBoxStyle

func (p BoxPrinter) WithBoxStyle(style *Style) *BoxPrinter

WithBoxStyle returns a new box with a specific box Style.

func (BoxPrinter) WithHorizontalString

func (p BoxPrinter) WithHorizontalString(str string) *BoxPrinter

WithHorizontalString returns a new box with a specific HorizontalString.

func (BoxPrinter) WithLeftPadding

func (p BoxPrinter) WithLeftPadding(padding int) *BoxPrinter

WithLeftPadding returns a new box with a specific LeftPadding.

func (BoxPrinter) WithRightPadding

func (p BoxPrinter) WithRightPadding(padding int) *BoxPrinter

WithRightPadding returns a new box with a specific RightPadding.

func (BoxPrinter) WithTextStyle

func (p BoxPrinter) WithTextStyle(style *Style) *BoxPrinter

WithTextStyle returns a new box with a specific text Style.

func (BoxPrinter) WithTitle

func (p BoxPrinter) WithTitle(str string) *BoxPrinter

WithTitle returns a new box with a specific Title.

func (BoxPrinter) WithTitleBottomCenter

func (p BoxPrinter) WithTitleBottomCenter(b ...bool) *BoxPrinter

WithTitleBottomCenter returns a new box with a specific Title alignment.

func (BoxPrinter) WithTitleBottomLeft

func (p BoxPrinter) WithTitleBottomLeft(b ...bool) *BoxPrinter

WithTitleBottomLeft returns a new box with a specific Title alignment.

func (BoxPrinter) WithTitleBottomRight

func (p BoxPrinter) WithTitleBottomRight(b ...bool) *BoxPrinter

WithTitleBottomRight returns a new box with a specific Title alignment.

func (BoxPrinter) WithTitleTopCenter

func (p BoxPrinter) WithTitleTopCenter(b ...bool) *BoxPrinter

WithTitleTopCenter returns a new box with a specific Title alignment.

func (BoxPrinter) WithTitleTopLeft

func (p BoxPrinter) WithTitleTopLeft(b ...bool) *BoxPrinter

WithTitleTopLeft returns a new box with a specific Title alignment.

func (BoxPrinter) WithTitleTopRight

func (p BoxPrinter) WithTitleTopRight(b ...bool) *BoxPrinter

WithTitleTopRight returns a new box with a specific Title alignment.

func (BoxPrinter) WithTopLeftCornerString

func (p BoxPrinter) WithTopLeftCornerString(str string) *BoxPrinter

WithTopLeftCornerString returns a new box with a specific TopLeftCornerString.

func (BoxPrinter) WithTopPadding

func (p BoxPrinter) WithTopPadding(padding int) *BoxPrinter

WithTopPadding returns a new box with a specific TopPadding.

func (BoxPrinter) WithTopRightCornerString

func (p BoxPrinter) WithTopRightCornerString(str string) *BoxPrinter

WithTopRightCornerString returns a new box with a specific TopRightCornerString.

func (BoxPrinter) WithVerticalString

func (p BoxPrinter) WithVerticalString(str string) *BoxPrinter

WithVerticalString returns a new box with a specific VerticalString.

func (BoxPrinter) WithWriter

func (p BoxPrinter) WithWriter(writer io.Writer) *BoxPrinter

WithWriter sets the custom Writer.

type BulletListItem

type BulletListItem struct {
	Level       int
	Text        string
	TextStyle   *Style
	Bullet      string
	BulletStyle *Style
}

BulletListItem is able to render a ListItem.

func NewBulletListItemFromString deprecated

func NewBulletListItemFromString(text string, padding string) BulletListItem

NewBulletListItemFromString returns a BulletListItem with a Text. The padding is counted in the Text to define the Level of the ListItem.

Deprecated: use putils.BulletListItemFromString instead.

func (BulletListItem) WithBullet

func (p BulletListItem) WithBullet(bullet string) *BulletListItem

WithBullet returns a new BulletListItem with a specific Prefix.

func (BulletListItem) WithBulletStyle

func (p BulletListItem) WithBulletStyle(style *Style) *BulletListItem

WithBulletStyle returns a new BulletListItem with a specific BulletStyle.

func (BulletListItem) WithLevel

func (p BulletListItem) WithLevel(level int) *BulletListItem

WithLevel returns a new BulletListItem with a specific Level.

func (BulletListItem) WithText

func (p BulletListItem) WithText(text string) *BulletListItem

WithText returns a new BulletListItem with a specific Text.

func (BulletListItem) WithTextStyle

func (p BulletListItem) WithTextStyle(style *Style) *BulletListItem

WithTextStyle returns a new BulletListItem with a specific TextStyle.

type BulletListPrinter

type BulletListPrinter struct {
	Items       []BulletListItem
	TextStyle   *Style
	Bullet      string
	BulletStyle *Style
	Writer      io.Writer
}

BulletListPrinter is able to render a list.

func NewBulletListFromString deprecated

func NewBulletListFromString(s string, padding string) BulletListPrinter

NewBulletListFromString returns a BulletListPrinter with Text using the NewTreeListItemFromString method, splitting after return (\n).

Deprecated: use putils.BulletListFromString instead.

func NewBulletListFromStrings deprecated

func NewBulletListFromStrings(s []string, padding string) BulletListPrinter

NewBulletListFromStrings returns a BulletListPrinter with Text using the NewTreeListItemFromString method.

Deprecated: use putils.BulletListFromStrings instead.

func (BulletListPrinter) Render

func (l BulletListPrinter) Render() error

Render prints the list to the terminal.

func (BulletListPrinter) Srender

func (l BulletListPrinter) Srender() (string, error)

Srender renders the list as a string.

func (BulletListPrinter) WithBullet

func (l BulletListPrinter) WithBullet(bullet string) *BulletListPrinter

WithBullet returns a new list with a specific bullet.

func (BulletListPrinter) WithBulletStyle

func (l BulletListPrinter) WithBulletStyle(style *Style) *BulletListPrinter

WithBulletStyle returns a new list with a specific bullet style.

func (BulletListPrinter) WithItems

func (l BulletListPrinter) WithItems(items []BulletListItem) *BulletListPrinter

WithItems returns a new list with specific Items.

func (BulletListPrinter) WithTextStyle

func (l BulletListPrinter) WithTextStyle(style *Style) *BulletListPrinter

WithTextStyle returns a new list with a specific text style.

func (BulletListPrinter) WithWriter

func (l BulletListPrinter) WithWriter(writer io.Writer) *BulletListPrinter

WithWriter sets the custom Writer.

type CenterPrinter

type CenterPrinter struct {
	CenterEachLineSeparately bool
	Writer                   io.Writer
}

CenterPrinter prints centered text.

func (CenterPrinter) Print

func (p CenterPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) PrintOnError

func (p CenterPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (CenterPrinter) PrintOnErrorf

func (p CenterPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (CenterPrinter) Printf

func (p CenterPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Printfln

func (p CenterPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Println

func (p CenterPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Sprint

func (p CenterPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (CenterPrinter) Sprintf

func (p CenterPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (CenterPrinter) Sprintfln

func (p CenterPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (CenterPrinter) Sprintln

func (p CenterPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (CenterPrinter) WithCenterEachLineSeparately

func (p CenterPrinter) WithCenterEachLineSeparately(b ...bool) *CenterPrinter

WithCenterEachLineSeparately centers each line separately.

func (CenterPrinter) WithWriter

func (p CenterPrinter) WithWriter(writer io.Writer) *CenterPrinter

WithWriter sets the custom Writer.

type Checkmark

type Checkmark struct {
	Checked   string
	Unchecked string
}

Checkmark is used in the interactive multiselect printer.

type Color

type Color uint8

Color is a number which will be used to color strings in the terminal.

const (
	FgBlack Color = iota + 30
	FgRed
	FgGreen
	FgYellow
	FgBlue
	FgMagenta
	FgCyan
	FgWhite
	// FgDefault revert default FG.
	FgDefault Color = 39
)

Foreground colors. basic foreground colors 30 - 37.

const (
	FgDarkGray Color = iota + 90
	FgLightRed
	FgLightGreen
	FgLightYellow
	FgLightBlue
	FgLightMagenta
	FgLightCyan
	FgLightWhite
	// FgGray is an alias of FgDarkGray.
	FgGray Color = 90
)

Extra foreground color 90 - 97.

const (
	BgBlack Color = iota + 40
	BgRed
	BgGreen
	BgYellow // BgBrown like yellow
	BgBlue
	BgMagenta
	BgCyan
	BgWhite
	// BgDefault reverts to the default background.
	BgDefault Color = 49
)

Background colors. basic background colors 40 - 47.

const (
	BgDarkGray Color = iota + 100
	BgLightRed
	BgLightGreen
	BgLightYellow
	BgLightBlue
	BgLightMagenta
	BgLightCyan
	BgLightWhite
	// BgGray is an alias of BgDarkGray.
	BgGray Color = 100
)

Extra background color 100 - 107.

const (
	Reset Color = iota
	Bold
	Fuzzy
	Italic
	Underscore
	Blink
	FastBlink
	Reverse
	Concealed
	Strikethrough
)

Option settings.

func (Color) Print

func (c Color) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) PrintOnError

func (c Color) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (Color) PrintOnErrorf

func (c Color) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (Color) Printf

func (c Color) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Printfln

func (c Color) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Println

func (c Color) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Sprint

func (c Color) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Color.

func (Color) Sprintf

func (c Color) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Color.

func (Color) Sprintfln

func (c Color) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Color.

func (Color) Sprintln

func (c Color) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Color.

func (Color) String

func (c Color) String() string

String converts the color to a string. eg "35".

func (Color) ToStyle

func (c Color) ToStyle() *Style

ToStyle converts the color to a style.

type HeaderPrinter

type HeaderPrinter struct {
	TextStyle       *Style
	BackgroundStyle *Style
	Margin          int
	FullWidth       bool
	Writer          io.Writer
}

HeaderPrinter contains the data used to craft a header. A header is printed as a big box with text in it. Can be used as title screens or section separator.

func (*HeaderPrinter) Print

func (p *HeaderPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*HeaderPrinter) PrintOnError

func (p *HeaderPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*HeaderPrinter) PrintOnErrorf

func (p *HeaderPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*HeaderPrinter) Printf

func (p *HeaderPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*HeaderPrinter) Printfln

func (p *HeaderPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*HeaderPrinter) Println

func (p *HeaderPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Sprint

func (p HeaderPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (HeaderPrinter) Sprintf

func (p HeaderPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (HeaderPrinter) Sprintfln

func (p HeaderPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (HeaderPrinter) Sprintln

func (p HeaderPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (HeaderPrinter) WithBackgroundStyle

func (p HeaderPrinter) WithBackgroundStyle(style *Style) *HeaderPrinter

WithBackgroundStyle changes the background styling of the header.

func (HeaderPrinter) WithFullWidth

func (p HeaderPrinter) WithFullWidth(b ...bool) *HeaderPrinter

WithFullWidth enables full width on a HeaderPrinter.

func (HeaderPrinter) WithMargin

func (p HeaderPrinter) WithMargin(margin int) *HeaderPrinter

WithMargin changes the background styling of the header.

func (HeaderPrinter) WithTextStyle

func (p HeaderPrinter) WithTextStyle(style *Style) *HeaderPrinter

WithTextStyle returns a new HeaderPrinter with changed

func (HeaderPrinter) WithWriter

func (p HeaderPrinter) WithWriter(writer io.Writer) *HeaderPrinter

WithWriter sets the custom Writer.

type HeatmapAxis

type HeatmapAxis struct {
	XAxis []string
	YAxis []string
}

type HeatmapData

type HeatmapData [][]float32

HeatmapData is the type that contains the data of a HeatmapPrinter.

type HeatmapPrinter

type HeatmapPrinter struct {
	HasHeader                  bool
	AxisStyle                  *Style
	VerticalSeparator          string
	TopRightCornerSeparator    string
	TopLeftCornerSeparator     string
	BottomLeftCornerSeparator  string
	BottomRightCornerSeparator string
	HorizontalSeparator        string
	TSeparator                 string
	TReverseSeparator          string
	LSeparator                 string
	LReverseSeparator          string
	TCrossSeparator            string
	LegendLabel                string
	SeparatorStyle             *Style
	Data                       HeatmapData
	Axis                       HeatmapAxis
	Boxed                      bool
	Grid                       bool
	OnlyColoredCells           bool
	LegendOnlyColoredCells     bool
	EnableComplementaryColor   bool
	Legend                     bool
	CellSize                   int
	Colors                     []Color
	TextColor                  Color
	EnableRGB                  bool
	RGBRange                   []RGB
	TextRGB                    RGB
	Writer                     io.Writer
	// contains filtered or unexported fields
}

HeatmapPrinter is able to render tables.

func (HeatmapPrinter) Render

func (p HeatmapPrinter) Render() error

Render prints the HeatmapPrinter to the terminal.

func (HeatmapPrinter) Srender

func (p HeatmapPrinter) Srender() (string, error)

Srender renders the HeatmapPrinter as a string.

func (HeatmapPrinter) WithAxisData

func (p HeatmapPrinter) WithAxisData(hd HeatmapAxis) *HeatmapPrinter

WithAxisData returns a new HeatmapPrinter, where the first line and row are headers.

func (HeatmapPrinter) WithAxisStyle

func (p HeatmapPrinter) WithAxisStyle(style *Style) *HeatmapPrinter

WithAxisStyle returns a new HeatmapPrinter with a specific AxisStyle.

func (HeatmapPrinter) WithBoxed

func (p HeatmapPrinter) WithBoxed(b ...bool) *HeatmapPrinter

WithBoxed returns a new HeatmapPrinter with a box around the table. If set to true, Grid will be set to true too.

func (HeatmapPrinter) WithCellSize

func (p HeatmapPrinter) WithCellSize(i int) *HeatmapPrinter

WithCellSize returns a new HeatmapPrinter with a specific cell size. This only works if there is no header and OnlyColoredCells == true!

func (HeatmapPrinter) WithColors

func (p HeatmapPrinter) WithColors(colors ...Color) *HeatmapPrinter

WithColors returns a new HeatmapPrinter with a specific Colors.

func (HeatmapPrinter) WithData

func (p HeatmapPrinter) WithData(data [][]float32) *HeatmapPrinter

WithData returns a new HeatmapPrinter with specific Data.

func (HeatmapPrinter) WithEnableComplementaryColor

func (p HeatmapPrinter) WithEnableComplementaryColor(b ...bool) *HeatmapPrinter

WithEnableComplementaryColor returns a new HeatmapPrinter with complement color.

func (HeatmapPrinter) WithEnableRGB

func (p HeatmapPrinter) WithEnableRGB(b ...bool) *HeatmapPrinter

WithEnableRGB returns a new HeatmapPrinter with RGB colors.

func (HeatmapPrinter) WithGrid

func (p HeatmapPrinter) WithGrid(b ...bool) *HeatmapPrinter

WithGrid returns a new HeatmapPrinter with a grid. If set to false, Boxed will be set to false too.

func (HeatmapPrinter) WithLegend

func (p HeatmapPrinter) WithLegend(b ...bool) *HeatmapPrinter

WithLegend returns a new HeatmapPrinter with a legend.

func (HeatmapPrinter) WithLegendLabel

func (p HeatmapPrinter) WithLegendLabel(s string) *HeatmapPrinter

WithLegendLabel returns a new HeatmapPrinter with a specific legend tag. This sets the Legend to true.

func (HeatmapPrinter) WithLegendOnlyColoredCells

func (p HeatmapPrinter) WithLegendOnlyColoredCells(b ...bool) *HeatmapPrinter

WithLegendOnlyColoredCells returns a new HeatmapPrinter with legend with only colored cells. This sets the Legend to true.

func (HeatmapPrinter) WithOnlyColoredCells

func (p HeatmapPrinter) WithOnlyColoredCells(b ...bool) *HeatmapPrinter

WithOnlyColoredCells returns a new HeatmapPrinter with only colored cells.

func (HeatmapPrinter) WithRGBRange

func (p HeatmapPrinter) WithRGBRange(rgb ...RGB) *HeatmapPrinter

WithRGBRange returns a new HeatmapPrinter with a specific RGBRange.

func (HeatmapPrinter) WithSeparatorStyle

func (p HeatmapPrinter) WithSeparatorStyle(style *Style) *HeatmapPrinter

WithSeparatorStyle returns a new HeatmapPrinter with a specific SeparatorStyle.

func (HeatmapPrinter) WithTextColor

func (p HeatmapPrinter) WithTextColor(color Color) *HeatmapPrinter

WithTextColor returns a new HeatmapPrinter with a specific TextColor. This sets EnableComplementaryColor to false.

func (HeatmapPrinter) WithTextRGB

func (p HeatmapPrinter) WithTextRGB(rgb RGB) *HeatmapPrinter

WithTextRGB returns a new HeatmapPrinter with a specific TextRGB. This sets EnableComplementaryColor to false.

func (HeatmapPrinter) WithWriter

func (p HeatmapPrinter) WithWriter(writer io.Writer) *HeatmapPrinter

WithWriter sets the Writer.

type InteractiveConfirmPrinter

type InteractiveConfirmPrinter struct {
	DefaultValue    bool
	DefaultText     string
	Delimiter       string
	TextStyle       *Style
	ConfirmText     string
	ConfirmStyle    *Style
	RejectText      string
	RejectStyle     *Style
	SuffixStyle     *Style
	OnInterruptFunc func()
}

InteractiveConfirmPrinter is a printer for interactive confirm prompts.

func (InteractiveConfirmPrinter) Show

func (p InteractiveConfirmPrinter) Show(text ...string) (bool, error)

Show shows the confirm prompt.

Example:

result, _ := pterm.DefaultInteractiveConfirm.Show("Are you sure?")
pterm.Println(result)

func (InteractiveConfirmPrinter) WithConfirmStyle

func (p InteractiveConfirmPrinter) WithConfirmStyle(style *Style) *InteractiveConfirmPrinter

WithConfirmStyle sets the confirm style.

func (InteractiveConfirmPrinter) WithConfirmText

WithConfirmText sets the confirm text.

func (InteractiveConfirmPrinter) WithDefaultText

WithDefaultText sets the default text.

func (InteractiveConfirmPrinter) WithDefaultValue

func (p InteractiveConfirmPrinter) WithDefaultValue(value bool) *InteractiveConfirmPrinter

WithDefaultValue sets the default value, which will be returned when the user presses enter without typing "y" or "n".

func (InteractiveConfirmPrinter) WithDelimiter

func (p InteractiveConfirmPrinter) WithDelimiter(delimiter string) *InteractiveConfirmPrinter

WithDelimiter sets the delimiter between the message and the input.

func (InteractiveConfirmPrinter) WithOnInterruptFunc

func (p InteractiveConfirmPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveConfirmPrinter

WithOnInterruptFunc sets the function to execute on exit of the input reader

func (InteractiveConfirmPrinter) WithRejectStyle

func (p InteractiveConfirmPrinter) WithRejectStyle(style *Style) *InteractiveConfirmPrinter

WithRejectStyle sets the reject style.

func (InteractiveConfirmPrinter) WithRejectText

WithRejectText sets the reject text.

func (InteractiveConfirmPrinter) WithSuffixStyle

func (p InteractiveConfirmPrinter) WithSuffixStyle(style *Style) *InteractiveConfirmPrinter

WithSuffixStyle sets the suffix style.

func (InteractiveConfirmPrinter) WithTextStyle

WithTextStyle sets the text style.

type InteractiveContinuePrinter

type InteractiveContinuePrinter struct {
	DefaultValueIndex int
	DefaultText       string
	Delimiter         string
	TextStyle         *Style
	Options           []string
	OptionsStyle      *Style
	Handles           []string
	ShowShortHandles  bool
	SuffixStyle       *Style
}

InteractiveContinuePrinter is a printer for interactive continue prompts.

func (InteractiveContinuePrinter) Show

func (p InteractiveContinuePrinter) Show(text ...string) (string, error)

Show shows the continue prompt.

Example:

result, _ := pterm.DefaultInteractiveContinue.Show("Do you want to apply the changes?")
pterm.Println(result)

func (InteractiveContinuePrinter) WithDefaultText

WithDefaultText sets the default text.

func (InteractiveContinuePrinter) WithDefaultValue

WithDefaultValue sets the default value, which will be returned when the user presses enter without typing any letter.

func (InteractiveContinuePrinter) WithDefaultValueIndex

func (p InteractiveContinuePrinter) WithDefaultValueIndex(value int) *InteractiveContinuePrinter

WithDefaultValueIndex sets the default value, which will be returned when the user presses enter without typing any letter.

func (InteractiveContinuePrinter) WithDelimiter

func (p InteractiveContinuePrinter) WithDelimiter(delimiter string) *InteractiveContinuePrinter

WithDelimiter sets the delimiter between the message and the input.

func (InteractiveContinuePrinter) WithHandles

WithHandles allows you to customize the short handles for the answers.

func (InteractiveContinuePrinter) WithOptions

WithOptions sets the options.

func (InteractiveContinuePrinter) WithOptionsStyle

func (p InteractiveContinuePrinter) WithOptionsStyle(style *Style) *InteractiveContinuePrinter

WithOptionsStyle sets the continue style.

func (InteractiveContinuePrinter) WithShowShortHandles

func (p InteractiveContinuePrinter) WithShowShortHandles(b ...bool) *InteractiveContinuePrinter

WithShowShortHandles will set ShowShortHandles to true this makes the printer display the shorthand options instead their shorthand version.

func (InteractiveContinuePrinter) WithSuffixStyle

func (p InteractiveContinuePrinter) WithSuffixStyle(style *Style) *InteractiveContinuePrinter

WithSuffixStyle sets the suffix style.

func (InteractiveContinuePrinter) WithTextStyle

WithTextStyle sets the text style.

type InteractiveMultiselectPrinter

type InteractiveMultiselectPrinter struct {
	DefaultText     string
	TextStyle       *Style
	Options         []string
	OptionStyle     *Style
	DefaultOptions  []string
	MaxHeight       int
	Selector        string
	SelectorStyle   *Style
	Filter          bool
	Checkmark       *Checkmark
	OnInterruptFunc func()

	// KeySelect is the select key. It cannot be keys.Space when Filter is enabled.
	KeySelect keys.KeyCode

	// KeyConfirm is the confirm key. It cannot be keys.Space when Filter is enabled.
	KeyConfirm keys.KeyCode
	// contains filtered or unexported fields
}

InteractiveMultiselectPrinter is a printer for interactive multiselect menus.

func (*InteractiveMultiselectPrinter) Show

func (p *InteractiveMultiselectPrinter) Show(text ...string) ([]string, error)

Show shows the interactive multiselect menu and returns the selected entry.

func (InteractiveMultiselectPrinter) WithCheckmark

WithCheckmark sets the checkmark

func (InteractiveMultiselectPrinter) WithDefaultOptions

func (p InteractiveMultiselectPrinter) WithDefaultOptions(options []string) *InteractiveMultiselectPrinter

WithDefaultOptions sets the default options.

func (InteractiveMultiselectPrinter) WithDefaultText

WithDefaultText sets the default text.

func (InteractiveMultiselectPrinter) WithFilter

WithFilter sets the Filter option

func (InteractiveMultiselectPrinter) WithKeyConfirm

WithKeyConfirm sets the confirm key It cannot be keys.Space when Filter is enabled.

func (InteractiveMultiselectPrinter) WithKeySelect

WithKeySelect sets the confirm key It cannot be keys.Space when Filter is enabled.

func (InteractiveMultiselectPrinter) WithMaxHeight

WithMaxHeight sets the maximum height of the select menu.

func (InteractiveMultiselectPrinter) WithOnInterruptFunc

func (p InteractiveMultiselectPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveMultiselectPrinter

OnInterrupt sets the function to execute on exit of the input reader

func (InteractiveMultiselectPrinter) WithOptions

WithOptions sets the options.

type InteractiveSelectPrinter

type InteractiveSelectPrinter struct {
	TextStyle       *Style
	DefaultText     string
	Options         []string
	OptionStyle     *Style
	DefaultOption   string
	MaxHeight       int
	Selector        string
	SelectorStyle   *Style
	OnInterruptFunc func()
	Filter          bool
	ErrorOnTab      bool
	// contains filtered or unexported fields
}

InteractiveSelectPrinter is a printer for interactive select menus.

func (*InteractiveSelectPrinter) Show

func (p *InteractiveSelectPrinter) Show(text ...string) (string, error)

Show shows the interactive select menu and returns the selected entry.

func (InteractiveSelectPrinter) WithDefaultOption

func (p InteractiveSelectPrinter) WithDefaultOption(option string) *InteractiveSelectPrinter

WithDefaultOption sets the default options.

func (InteractiveSelectPrinter) WithDefaultText

func (p InteractiveSelectPrinter) WithDefaultText(text string) *InteractiveSelectPrinter

WithDefaultText sets the default text.

func (InteractiveSelectPrinter) WithErrorOnTab

func (p InteractiveSelectPrinter) WithErrorOnTab(b ...bool) *InteractiveSelectPrinter

WithErrorOnTab sets the ErrorOnTab option

func (InteractiveSelectPrinter) WithFilter

WithFilter sets the Filter option

func (InteractiveSelectPrinter) WithMaxHeight

func (p InteractiveSelectPrinter) WithMaxHeight(maxHeight int) *InteractiveSelectPrinter

WithMaxHeight sets the maximum height of the select menu.

func (InteractiveSelectPrinter) WithOnInterruptFunc

func (p InteractiveSelectPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveSelectPrinter

WithOnInterruptFunc sets the function to execute on exit of the input reader

func (InteractiveSelectPrinter) WithOptions

func (p InteractiveSelectPrinter) WithOptions(options []string) *InteractiveSelectPrinter

WithOptions sets the options.

type InteractiveTextInputPrinter

type InteractiveTextInputPrinter struct {
	TextStyle       *Style
	DefaultText     string
	DefaultValue    string
	Delimiter       string
	MultiLine       bool
	Mask            string
	InputColor      Color
	OnInterruptFunc func()
	ErrorOnTab      bool
	OnUpDown        func(input string, isUp bool) string
	// contains filtered or unexported fields
}

InteractiveTextInputPrinter is a printer for interactive select menus.

func (InteractiveTextInputPrinter) Show

func (p InteractiveTextInputPrinter) Show(text ...string) (string, error)

Show shows the interactive select menu and returns the selected entry.

func (InteractiveTextInputPrinter) WithDefaultText

WithDefaultText sets the default text.

func (InteractiveTextInputPrinter) WithDefaultValue

WithDefaultValue sets the default value.

func (InteractiveTextInputPrinter) WithDelimiter

WithDelimiter sets the delimiter between the message and the input.

func (InteractiveTextInputPrinter) WithErrorOnTab

WithErrorOnTab sets the ErrorOnTab option

func (InteractiveTextInputPrinter) WithInputColor

WithInputColor sets the input color.

func (InteractiveTextInputPrinter) WithMask

WithMask sets the mask.

func (InteractiveTextInputPrinter) WithMultiLine

func (p InteractiveTextInputPrinter) WithMultiLine(multiLine ...bool) *InteractiveTextInputPrinter

WithMultiLine sets the multi line flag.

func (InteractiveTextInputPrinter) WithOnInterruptFunc

func (p InteractiveTextInputPrinter) WithOnInterruptFunc(exitFunc func()) *InteractiveTextInputPrinter

WithOnInterruptFunc sets the function to execute on exit of the input reader

func (InteractiveTextInputPrinter) WithOnUpDown

func (p InteractiveTextInputPrinter) WithOnUpDown(f func(input string, isUp bool) string) *InteractiveTextInputPrinter

WithOnUpDown sets the OnUpDown option

func (InteractiveTextInputPrinter) WithTextStyle

WithTextStyle sets the text style.

type Letter

type Letter struct {
	String string
	Style  *Style
	RGB    RGB
}

Letter is an object, which holds a string and a specific Style for it.

func (Letter) WithRGB

func (l Letter) WithRGB(rgb RGB) *Letter

WithRGB returns a new Letter with a specific RGB color (overwrites style).

func (Letter) WithString

func (l Letter) WithString(s string) *Letter

WithString returns a new Letter with a specific String.

func (Letter) WithStyle

func (l Letter) WithStyle(style *Style) *Letter

WithStyle returns a new Letter with a specific Style.

type Letters

type Letters []Letter

Letters is a slice of Letter.

func NewLettersFromString deprecated

func NewLettersFromString(text string) Letters

NewLettersFromString creates a Letters object from a string, which is prefilled with the LetterStyle from ThemeDefault. You can override the ThemeDefault LetterStyle if you want to.

Deprecated: use putils.LettersFromString instead.

func NewLettersFromStringWithRGB deprecated

func NewLettersFromStringWithRGB(text string, rgb RGB) Letters

NewLettersFromStringWithRGB creates a Letters object from a string and applies an RGB color to it (overwrites style).

Deprecated: use putils.LettersFromStringWithRGB instead.

func NewLettersFromStringWithStyle deprecated

func NewLettersFromStringWithStyle(text string, style *Style) Letters

NewLettersFromStringWithStyle creates a Letters object from a string and applies a Style to it.

Deprecated: use putils.LettersFromStringWithStyle instead.

type LeveledList

type LeveledList []LeveledListItem

LeveledList is a list, which contains multiple LeveledListItem.

type LeveledListItem

type LeveledListItem struct {
	Level int
	Text  string
}

LeveledListItem combines a text with a specific level. The level is the indent, which would normally be seen in a BulletListPrinter.

type LivePrinter

type LivePrinter interface {
	// GenericStart runs Start, but returns a LivePrinter.
	// This is used for the interface LivePrinter.
	// You most likely want to use Start instead of this in your program.
	GenericStart() (*LivePrinter, error)

	// GenericStop runs Stop, but returns a LivePrinter.
	// This is used for the interface LivePrinter.
	// You most likely want to use Stop instead of this in your program.
	GenericStop() (*LivePrinter, error)

	SetWriter(writer io.Writer)
}

LivePrinter is a printer which can update it's output live.

type LogFormatter

type LogFormatter int

LogFormatter is the log formatter. Can be either LogFormatterColorful or LogFormatterJSON.

const (
	// LogFormatterColorful is a colorful log formatter.
	LogFormatterColorful LogFormatter = iota
	// LogFormatterJSON is a JSON log formatter.
	LogFormatterJSON
)

type LogLevel

type LogLevel int
const (
	// LogLevelDisabled does never print.
	LogLevelDisabled LogLevel = iota
	// LogLevelTrace is the log level for traces.
	LogLevelTrace
	// LogLevelDebug is the log level for debug.
	LogLevelDebug
	// LogLevelInfo is the log level for info.
	LogLevelInfo
	// LogLevelWarn is the log level for warnings.
	LogLevelWarn
	// LogLevelError is the log level for errors.
	LogLevelError
	// LogLevelFatal is the log level for fatal errors.
	LogLevelFatal
	// LogLevelPrint is the log level for printing.
	LogLevelPrint
)

func (LogLevel) String

func (l LogLevel) String() string

func (LogLevel) Style

func (l LogLevel) Style() Style

Style returns the style of the log level.

type Logger

type Logger struct {
	// Formatter is the log formatter of the logger.
	Formatter LogFormatter
	// Writer is the writer of the logger.
	Writer io.Writer
	// Level is the log level of the logger.
	Level LogLevel
	// ShowCaller defines if the logger should print the caller.
	ShowCaller bool
	// CallerOffset defines the offset of the caller.
	CallerOffset int
	// ShowTime defines if the logger should print a timestamp.
	ShowTime bool
	// TimestampLayout defines the layout of the timestamp.
	TimeFormat string
	// KeyStyles defines the styles for specific keys.
	KeyStyles map[string]Style
	// MaxWidth defines the maximum width of the logger.
	// If the text (including the arguments) is longer than the max width, it will be split into multiple lines.
	MaxWidth int
}

func (Logger) AppendKeyStyle

func (l Logger) AppendKeyStyle(key string, style Style) *Logger

AppendKeyStyle appends a style for a specific key.

func (Logger) AppendKeyStyles

func (l Logger) AppendKeyStyles(styles map[string]Style) *Logger

AppendKeyStyles appends a style for a specific key.

func (Logger) Args

func (l Logger) Args(args ...any) []LoggerArgument

Args converts any arguments to a slice of LoggerArgument.

func (Logger) ArgsFromMap

func (l Logger) ArgsFromMap(m map[string]any) []LoggerArgument

ArgsFromMap converts a map to a slice of LoggerArgument.

func (Logger) CanPrint

func (l Logger) CanPrint(level LogLevel) bool

CanPrint checks if the logger can print a specific log level.

func (Logger) Debug

func (l Logger) Debug(msg string, args ...[]LoggerArgument)

Debug prints a debug log.

func (Logger) Error

func (l Logger) Error(msg string, args ...[]LoggerArgument)

Error prints an error log.

func (Logger) Fatal

func (l Logger) Fatal(msg string, args ...[]LoggerArgument)

Fatal prints a fatal log and exits the program.

func (Logger) Info

func (l Logger) Info(msg string, args ...[]LoggerArgument)

Info prints an info log.

func (Logger) Print

func (l Logger) Print(msg string, args ...[]LoggerArgument)

Print prints a log.

func (Logger) Trace

func (l Logger) Trace(msg string, args ...[]LoggerArgument)

Trace prints a trace log.

func (Logger) Warn

func (l Logger) Warn(msg string, args ...[]LoggerArgument)

Warn prints a warning log.

func (Logger) WithCaller

func (l Logger) WithCaller(b ...bool) *Logger

WithCaller enables or disables the caller.

func (Logger) WithCallerOffset

func (l Logger) WithCallerOffset(offset int) *Logger

WithCallerOffset sets the caller offset.

func (Logger) WithFormatter

func (l Logger) WithFormatter(formatter LogFormatter) *Logger

WithFormatter sets the log formatter of the logger.

func (Logger) WithKeyStyles

func (l Logger) WithKeyStyles(styles map[string]Style) *Logger

WithKeyStyles sets the style for a specific key.

func (Logger) WithLevel

func (l Logger) WithLevel(level LogLevel) *Logger

WithLevel sets the log level of the logger.

func (Logger) WithMaxWidth

func (l Logger) WithMaxWidth(width int) *Logger

WithMaxWidth sets the maximum width of the logger.

func (Logger) WithTime

func (l Logger) WithTime(b ...bool) *Logger

WithTime enables or disables the timestamp.

func (Logger) WithTimeFormat

func (l Logger) WithTimeFormat(format string) *Logger

WithTimeFormat sets the timestamp layout.

func (Logger) WithWriter

func (l Logger) WithWriter(writer io.Writer) *Logger

WithWriter sets the writer of the logger.

type LoggerArgument

type LoggerArgument struct {
	// Key is the key of the argument.
	Key string
	// Value is the value of the argument.
	Value any
}

LoggerArgument is a key-value pair for a logger.

type MultiPrinter

type MultiPrinter struct {
	IsActive    bool
	Writer      io.Writer
	UpdateDelay time.Duration
	// contains filtered or unexported fields
}

func (MultiPrinter) GenericStart

func (p MultiPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (MultiPrinter) GenericStop

func (p MultiPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (*MultiPrinter) NewWriter

func (p *MultiPrinter) NewWriter() io.Writer

func (*MultiPrinter) SetWriter

func (p *MultiPrinter) SetWriter(writer io.Writer)

SetWriter sets the writer for the AreaPrinter.

func (*MultiPrinter) Start

func (p *MultiPrinter) Start() (*MultiPrinter, error)

func (*MultiPrinter) Stop

func (p *MultiPrinter) Stop() (*MultiPrinter, error)

func (MultiPrinter) WithUpdateDelay

func (p MultiPrinter) WithUpdateDelay(delay time.Duration) *MultiPrinter

WithUpdateDelay returns a fork of the MultiPrinter with a new update delay.

func (MultiPrinter) WithWriter

func (p MultiPrinter) WithWriter(writer io.Writer) *MultiPrinter

WithWriter returns a fork of the MultiPrinter with a new writer.

type Panel

type Panel struct {
	Data string
}

Panel contains the data, which should be printed inside a PanelPrinter.

type PanelPrinter

type PanelPrinter struct {
	Panels          Panels
	Padding         int
	BottomPadding   int
	SameColumnWidth bool
	BoxPrinter      BoxPrinter
	Writer          io.Writer
}

PanelPrinter prints content in boxes.

func (PanelPrinter) Render

func (p PanelPrinter) Render() error

Render prints the Template to the terminal.

func (PanelPrinter) Srender

func (p PanelPrinter) Srender() (string, error)

Srender renders the Template as a string.

func (PanelPrinter) WithBottomPadding

func (p PanelPrinter) WithBottomPadding(bottomPadding int) *PanelPrinter

WithBottomPadding returns a new PanelPrinter with specific options.

func (PanelPrinter) WithBoxPrinter

func (p PanelPrinter) WithBoxPrinter(boxPrinter BoxPrinter) *PanelPrinter

WithBoxPrinter returns a new PanelPrinter with specific options.

func (PanelPrinter) WithPadding

func (p PanelPrinter) WithPadding(padding int) *PanelPrinter

WithPadding returns a new PanelPrinter with specific options.

func (PanelPrinter) WithPanels

func (p PanelPrinter) WithPanels(panels Panels) *PanelPrinter

WithPanels returns a new PanelPrinter with specific options.

func (PanelPrinter) WithSameColumnWidth

func (p PanelPrinter) WithSameColumnWidth(b ...bool) *PanelPrinter

WithSameColumnWidth returns a new PanelPrinter with specific options.

func (PanelPrinter) WithWriter

func (p PanelPrinter) WithWriter(writer io.Writer) *PanelPrinter

WithWriter sets the custom Writer.

type Panels

type Panels [][]Panel

Panels is a two dimensional coordinate system for Panel.

type ParagraphPrinter

type ParagraphPrinter struct {
	MaxWidth int
	Writer   io.Writer
}

ParagraphPrinter can print paragraphs to a fixed line width. The text will split between words, so that words will stick together. It's like in a book.

func (*ParagraphPrinter) Print

func (p *ParagraphPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*ParagraphPrinter) PrintOnError

func (p *ParagraphPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*ParagraphPrinter) PrintOnErrorf

func (p *ParagraphPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*ParagraphPrinter) Printf

func (p *ParagraphPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*ParagraphPrinter) Printfln

func (p *ParagraphPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*ParagraphPrinter) Println

func (p *ParagraphPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (ParagraphPrinter) Sprint

func (p ParagraphPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (ParagraphPrinter) Sprintf

func (p ParagraphPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (ParagraphPrinter) Sprintfln

func (p ParagraphPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (ParagraphPrinter) Sprintln

func (p ParagraphPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (ParagraphPrinter) WithMaxWidth

func (p ParagraphPrinter) WithMaxWidth(width int) *ParagraphPrinter

WithMaxWidth returns a new ParagraphPrinter with a specific MaxWidth

func (ParagraphPrinter) WithWriter

func (p ParagraphPrinter) WithWriter(writer io.Writer) *ParagraphPrinter

WithWriter sets the custom Writer.

type Prefix

type Prefix struct {
	Text  string
	Style *Style
}

Prefix contains the data used as the beginning of a printed text via a PrefixPrinter.

type PrefixPrinter

type PrefixPrinter struct {
	Prefix           Prefix
	Scope            Scope
	MessageStyle     *Style
	Fatal            bool
	ShowLineNumber   bool
	LineNumberOffset int
	Writer           io.Writer
	// If Debugger is true, the printer will only print if PrintDebugMessages is set to true.
	// You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.
	Debugger bool
}

PrefixPrinter is the printer used to print a Prefix.

func (PrefixPrinter) GetFormattedPrefix

func (p PrefixPrinter) GetFormattedPrefix() string

GetFormattedPrefix returns the Prefix as a styled text string.

func (*PrefixPrinter) Print

func (p *PrefixPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) PrintOnError

func (p *PrefixPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

Note: Use WithFatal(true) or Fatal to panic after first non nil error.

func (*PrefixPrinter) PrintOnErrorf

func (p *PrefixPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*PrefixPrinter) Printf

func (p *PrefixPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Printfln

func (p *PrefixPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Println

func (p *PrefixPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Sprint

func (p *PrefixPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (PrefixPrinter) Sprintf

func (p PrefixPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (PrefixPrinter) Sprintfln

func (p PrefixPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (PrefixPrinter) Sprintln

func (p PrefixPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (PrefixPrinter) WithDebugger

func (p PrefixPrinter) WithDebugger(b ...bool) *PrefixPrinter

WithDebugger returns a new Printer with specific Debugger value. If Debugger is true, the printer will only print if PrintDebugMessages is set to true. You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.

func (PrefixPrinter) WithFatal

func (p PrefixPrinter) WithFatal(b ...bool) *PrefixPrinter

WithFatal sets if the printer should panic after printing. NOTE: The printer will only panic if either PrefixPrinter.Println, PrefixPrinter.Print or PrefixPrinter.Printf is called.

func (PrefixPrinter) WithLineNumberOffset

func (p PrefixPrinter) WithLineNumberOffset(offset int) *PrefixPrinter

WithLineNumberOffset can be used to exclude a specific amount of calls in the call stack. If you make a wrapper function for example, you can set this to one. The printed line number will then be the line number where your wrapper function is called.

func (PrefixPrinter) WithMessageStyle

func (p PrefixPrinter) WithMessageStyle(style *Style) *PrefixPrinter

WithMessageStyle adds a custom prefix to the printer.

func (PrefixPrinter) WithPrefix

func (p PrefixPrinter) WithPrefix(prefix Prefix) *PrefixPrinter

WithPrefix adds a custom prefix to the printer.

func (PrefixPrinter) WithScope

func (p PrefixPrinter) WithScope(scope Scope) *PrefixPrinter

WithScope adds a scope to the Prefix.

func (PrefixPrinter) WithShowLineNumber

func (p PrefixPrinter) WithShowLineNumber(b ...bool) *PrefixPrinter

WithShowLineNumber sets if the printer should print the line number from where it's called in a go file.

func (PrefixPrinter) WithWriter

func (p PrefixPrinter) WithWriter(writer io.Writer) *PrefixPrinter

WithWriter sets the custom Writer.

type ProgressbarPrinter

type ProgressbarPrinter struct {
	Title                     string
	Total                     int
	Current                   int
	BarCharacter              string
	LastCharacter             string
	ElapsedTimeRoundingFactor time.Duration
	BarFiller                 string
	MaxWidth                  int

	ShowElapsedTime bool
	ShowCount       bool
	ShowTitle       bool
	ShowPercentage  bool
	RemoveWhenDone  bool

	TitleStyle *Style
	BarStyle   *Style

	IsActive bool

	Writer io.Writer
	// contains filtered or unexported fields
}

ProgressbarPrinter shows a progress animation in the terminal.

func (*ProgressbarPrinter) Add

func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter

Add to current value.

func (*ProgressbarPrinter) GenericStart

func (p *ProgressbarPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (*ProgressbarPrinter) GenericStop

func (p *ProgressbarPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (*ProgressbarPrinter) GetElapsedTime

func (p *ProgressbarPrinter) GetElapsedTime() time.Duration

GetElapsedTime returns the elapsed time, since the ProgressbarPrinter was started.

func (*ProgressbarPrinter) Increment

func (p *ProgressbarPrinter) Increment() *ProgressbarPrinter

Increment current value by one.

func (*ProgressbarPrinter) ResetTimer

func (p *ProgressbarPrinter) ResetTimer()

ResetTimer resets the timer of the ProgressbarPrinter.

func (*ProgressbarPrinter) SetStartedAt

func (p *ProgressbarPrinter) SetStartedAt(t time.Time)

SetStartedAt sets the time when the ProgressbarPrinter started.

func (*ProgressbarPrinter) SetWriter

func (p *ProgressbarPrinter) SetWriter(writer io.Writer)

SetWriter sets the custom Writer.

func (ProgressbarPrinter) Start

func (p ProgressbarPrinter) Start(title ...interface{}) (*ProgressbarPrinter, error)

Start the ProgressbarPrinter.

func (*ProgressbarPrinter) Stop

Stop the ProgressbarPrinter.

func (*ProgressbarPrinter) UpdateTitle

func (p *ProgressbarPrinter) UpdateTitle(title string) *ProgressbarPrinter

UpdateTitle updates the title and re-renders the progressbar

func (ProgressbarPrinter) WithBarCharacter

func (p ProgressbarPrinter) WithBarCharacter(char string) *ProgressbarPrinter

WithBarCharacter sets the bar character of the ProgressbarPrinter.

func (ProgressbarPrinter) WithBarFiller

func (p ProgressbarPrinter) WithBarFiller(char string) *ProgressbarPrinter

WithBarFiller sets the filler character for the ProgressbarPrinter.

func (ProgressbarPrinter) WithBarStyle

func (p ProgressbarPrinter) WithBarStyle(style *Style) *ProgressbarPrinter

WithBarStyle sets the style of the bar.

func (ProgressbarPrinter) WithCurrent

func (p ProgressbarPrinter) WithCurrent(current int) *ProgressbarPrinter

WithCurrent sets the current value of the ProgressbarPrinter.

func (ProgressbarPrinter) WithElapsedTimeRoundingFactor

func (p ProgressbarPrinter) WithElapsedTimeRoundingFactor(duration time.Duration) *ProgressbarPrinter

WithElapsedTimeRoundingFactor sets the rounding factor of the elapsed time.

func (ProgressbarPrinter) WithLastCharacter

func (p ProgressbarPrinter) WithLastCharacter(char string) *ProgressbarPrinter

WithLastCharacter sets the last character of the ProgressbarPrinter.

func (ProgressbarPrinter) WithMaxWidth

func (p ProgressbarPrinter) WithMaxWidth(maxWidth int) *ProgressbarPrinter

WithMaxWidth sets the maximum width of the ProgressbarPrinter. If the terminal is smaller than the given width, the terminal width will be used instead. If the width is set to zero, or below, the terminal width will be used.

func (ProgressbarPrinter) WithRemoveWhenDone

func (p ProgressbarPrinter) WithRemoveWhenDone(b ...bool) *ProgressbarPrinter

WithRemoveWhenDone sets if the ProgressbarPrinter should be removed when it is done.

func (ProgressbarPrinter) WithShowCount

func (p ProgressbarPrinter) WithShowCount(b ...bool) *ProgressbarPrinter

WithShowCount sets if the total and current count should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowElapsedTime

func (p ProgressbarPrinter) WithShowElapsedTime(b ...bool) *ProgressbarPrinter

WithShowElapsedTime sets if the elapsed time should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowPercentage

func (p ProgressbarPrinter) WithShowPercentage(b ...bool) *ProgressbarPrinter

WithShowPercentage sets if the completed percentage should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowTitle

func (p ProgressbarPrinter) WithShowTitle(b ...bool) *ProgressbarPrinter

WithShowTitle sets if the title should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithStartedAt

func (p ProgressbarPrinter) WithStartedAt(t time.Time) *ProgressbarPrinter

WithStartedAt sets the time when the ProgressbarPrinter started.

func (ProgressbarPrinter) WithTitle

func (p ProgressbarPrinter) WithTitle(name string) *ProgressbarPrinter

WithTitle sets the name of the ProgressbarPrinter.

func (ProgressbarPrinter) WithTitleStyle

func (p ProgressbarPrinter) WithTitleStyle(style *Style) *ProgressbarPrinter

WithTitleStyle sets the style of the title.

func (ProgressbarPrinter) WithTotal

func (p ProgressbarPrinter) WithTotal(total int) *ProgressbarPrinter

WithTotal sets the total value of the ProgressbarPrinter.

func (ProgressbarPrinter) WithWriter

func (p ProgressbarPrinter) WithWriter(writer io.Writer) *ProgressbarPrinter

WithWriter sets the custom Writer.

type RGB

type RGB struct {
	R          uint8
	G          uint8
	B          uint8
	Background bool
}

RGB color model is an additive color model in which red, green, and blue light are added together in various ways to reproduce a broad array of colors. The name of the model comes from the initials of the three additive primary colors, red, green, and blue. https://en.wikipedia.org/wiki/RGB_color_model

func NewRGB

func NewRGB(r, g, b uint8, background ...bool) RGB

NewRGB returns a new RGB.

func NewRGBFromHEX deprecated

func NewRGBFromHEX(hex string) (RGB, error)

NewRGBFromHEX converts a HEX and returns a new RGB.

Deprecated: use putils.RGBFromHEX instead.

func (RGB) Fade

func (p RGB) Fade(min, max, current float32, end ...RGB) RGB

Fade fades one RGB value (over other RGB values) to another RGB value, by giving the function a minimum, maximum and current value.

func (RGB) GetValues

func (p RGB) GetValues() (r, g, b uint8)

GetValues returns the RGB values separately.

func (RGB) Print

func (p RGB) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (RGB) PrintOnError

func (p RGB) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (RGB) PrintOnErrorf

func (p RGB) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (RGB) Printf

func (p RGB) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (RGB) Printfln

func (p RGB) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (RGB) Println

func (p RGB) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (RGB) Sprint

func (p RGB) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (RGB) Sprintf

func (p RGB) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (RGB) Sprintfln

func (p RGB) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (RGB) Sprintln

func (p RGB) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (RGB) ToRGBStyle

func (p RGB) ToRGBStyle() RGBStyle

type RGBStyle

type RGBStyle struct {
	Options                []Color
	Foreground, Background RGB
	// contains filtered or unexported fields
}

func NewRGBStyle

func NewRGBStyle(foreground RGB, background ...RGB) RGBStyle

NewRGBStyle returns a new RGBStyle. The foreground color is required, the background color is optional. The colors will be set as is, ignoring the RGB.Background property.

func (RGBStyle) AddOptions

func (p RGBStyle) AddOptions(opts ...Color) RGBStyle

AddOptions adds options to the RGBStyle.

func (RGBStyle) Print

func (p RGBStyle) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (RGBStyle) PrintOnError

func (p RGBStyle) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (RGBStyle) PrintOnErrorf

func (p RGBStyle) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (RGBStyle) Printf

func (p RGBStyle) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (RGBStyle) Printfln

func (p RGBStyle) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (RGBStyle) Println

func (p RGBStyle) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (RGBStyle) Sprint

func (p RGBStyle) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (RGBStyle) Sprintf

func (p RGBStyle) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (RGBStyle) Sprintfln

func (p RGBStyle) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (RGBStyle) Sprintln

func (p RGBStyle) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

type RenderPrinter

type RenderPrinter interface {
	// Render the XXX to the terminal.
	Render() error

	// Srender returns the rendered string of XXX.
	Srender() (string, error)
}

RenderPrinter is used to display renderable content. Example for renderable content is a Table.

type Scope

type Scope struct {
	Text  string
	Style *Style
}

Scope contains the data of the optional scope of a prefix. If it has a text, it will be printed after the Prefix in brackets.

type SectionPrinter

type SectionPrinter struct {
	Style           *Style
	Level           int
	IndentCharacter string
	TopPadding      int
	BottomPadding   int
	Writer          io.Writer
}

SectionPrinter prints a new section title. It can be used to structure longer text, or different chapters of your program.

func (*SectionPrinter) Print

func (p *SectionPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*SectionPrinter) PrintOnError

func (p *SectionPrinter) PrintOnError(a ...interface{}) *TextPrinter

PrintOnError prints every error which is not nil. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*SectionPrinter) PrintOnErrorf

func (p *SectionPrinter) PrintOnErrorf(format string, a ...interface{}) *TextPrinter

PrintOnErrorf wraps every error which is not nil and prints it. If every error is nil, nothing will be printed. This can be used for simple error checking.

func (*SectionPrinter) Printf

func (p *SectionPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*SectionPrinter) Printfln

func (p *SectionPrinter) Printfln(format string, a ...interface{}) *TextPrinter

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*SectionPrinter) Println

func (p *SectionPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (SectionPrinter) Sprint

func (p SectionPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (SectionPrinter) Sprintf

func (p SectionPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (SectionPrinter) Sprintfln

func (p SectionPrinter) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (SectionPrinter) Sprintln

func (p SectionPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (SectionPrinter) WithBottomPadding

func (p SectionPrinter) WithBottomPadding(padding int) *SectionPrinter

WithBottomPadding returns a new SectionPrinter with a specific top padding.

func (SectionPrinter) WithIndentCharacter

func (p SectionPrinter) WithIndentCharacter(char string) *SectionPrinter

WithIndentCharacter returns a new SectionPrinter with a specific IndentCharacter.

func (SectionPrinter) WithLevel

func (p SectionPrinter) WithLevel(level int) *SectionPrinter

WithLevel returns a new SectionPrinter with a specific level.

func (SectionPrinter) WithStyle

func (p SectionPrinter) WithStyle(style *Style) *SectionPrinter

WithStyle returns a new SectionPrinter with a specific style.

func (SectionPrinter) WithTopPadding

func (p SectionPrinter) WithTopPadding(padding int) *SectionPrinter

WithTopPadding returns a new SectionPrinter with a specific top padding.

func (SectionPrinter) WithWriter

func (p SectionPrinter) WithWriter(writer io.Writer) *SectionPrinter

WithWriter sets the custom Writer.

type SlogHandler

type SlogHandler struct {
	// contains filtered or unexported fields
}

func NewSlogHandler

func NewSlogHandler(logger *Logger) *SlogHandler

NewSlogHandler returns a new logging handler that can be intrgrated with log/slog.

func (*SlogHandler) Enabled

func (s *SlogHandler) Enabled(ctx context.Context, level slog.Level) bool

Enabled returns true if the given level is enabled.

func (*SlogHandler) Handle

func (s *SlogHandler) Handle(ctx context.Context, record slog.Record) error

Handle handles the given record.

func (*SlogHandler) WithAttrs

func (s *SlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler

WithAttrs returns a new handler with the given attributes.

func (*SlogHandler) WithGroup

func (s *SlogHandler) WithGroup(name string) slog.Handler

WithGroup is not yet supported.

type SpinnerPrinter

type SpinnerPrinter struct {
	Text                string
	Sequence            []string
	Style               *Style
	Delay               time.Duration
	MessageStyle        *Style
	InfoPrinter         TextPrinter
	SuccessPrinter      TextPrinter
	FailPrinter         TextPrinter
	WarningPrinter      TextPrinter
	RemoveWhenDone      bool
	ShowTimer           bool
	TimerRoundingFactor time.Duration
	TimerStyle          *Style

	IsActive bool

	Writer io.Writer
	// contains filtered or unexported fields
}

SpinnerPrinter is a loading animation, which can be used if the progress is unknown. It's an animation loop, which can have a text and supports throwing errors or warnings. A TextPrinter is used to display all outputs, after the SpinnerPrinter is done.

func (*SpinnerPrinter) Fail

func (s *SpinnerPrinter) Fail(message ...interface{})

Fail displays the fail printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (*SpinnerPrinter) GenericStart

func (s *SpinnerPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (*SpinnerPrinter) GenericStop

func (s *SpinnerPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (*SpinnerPrinter) Info

func (s *SpinnerPrinter) Info(message ...interface{})

Info displays an info message If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (*SpinnerPrinter) ResetTimer

func (s *SpinnerPrinter) ResetTimer()

ResetTimer resets the timer of the SpinnerPrinter.

func (*SpinnerPrinter) SetStartedAt

func (s *SpinnerPrinter) SetStartedAt(t time.Time)

SetStartedAt sets the time when the SpinnerPrinter started.

func (*SpinnerPrinter) SetWriter

func (p *SpinnerPrinter) SetWriter(writer io.Writer)

SetWriter sets the custom Writer.

func (SpinnerPrinter) Start

func (s SpinnerPrinter) Start(text ...interface{}) (*SpinnerPrinter, error)

Start the SpinnerPrinter.

func (*SpinnerPrinter) Stop

func (s *SpinnerPrinter) Stop() error

Stop terminates the SpinnerPrinter immediately. The SpinnerPrinter will not resolve into anything.

func (*SpinnerPrinter) Success

func (s *SpinnerPrinter) Success(message ...interface{})

Success displays the success printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (*SpinnerPrinter) UpdateText

func (s *SpinnerPrinter) UpdateText(text string)

UpdateText updates the message of the active SpinnerPrinter. Can be used live.

func (*SpinnerPrinter) Warning

func (s *SpinnerPrinter) Warning(message ...interface{})

Warning displays the warning printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (SpinnerPrinter) WithDelay

func (s SpinnerPrinter) WithDelay(delay time.Duration) *SpinnerPrinter

WithDelay adds a delay to the SpinnerPrinter.

func (SpinnerPrinter) WithMessageStyle

func (s SpinnerPrinter) WithMessageStyle(style *Style) *SpinnerPrinter

WithMessageStyle adds a style to the SpinnerPrinter message.

func (SpinnerPrinter) WithRemoveWhenDone

func (s SpinnerPrinter) WithRemoveWhenDone(b ...bool) *SpinnerPrinter

WithRemoveWhenDone removes the SpinnerPrinter after it is done.

func (SpinnerPrinter) WithSequence

func (s SpinnerPrinter) WithSequence(sequence ...string) *SpinnerPrinter

WithSequence adds a sequence to the SpinnerPrinter.

func (SpinnerPrinter) WithShowTimer

func (s SpinnerPrinter) WithShowTimer(b ...bool) *SpinnerPrinter

WithShowTimer shows how long the spinner is running.

func (SpinnerPrinter) WithStartedAt

func (s SpinnerPrinter) WithStartedAt(t time.Time) *SpinnerPrinter

WithStartedAt sets the time when the SpinnerPrinter started.

func (SpinnerPrinter) WithStyle

func (s SpinnerPrinter) WithStyle(style *Style) *SpinnerPrinter

WithStyle adds a style to the SpinnerPrinter.

func (SpinnerPrinter) WithText

func (s SpinnerPrinter) WithText(text string) *SpinnerPrinter

WithText adds a text to the SpinnerPrinter.

func (SpinnerPrinter) WithTimerRoundingFactor

func (s SpinnerPrinter) WithTimerRoundingFactor(factor time.Duration) *SpinnerPrinter

WithTimerRoundingFactor sets the rounding factor for the timer.

func (SpinnerPrinter) WithTimerStyle

func (s SpinnerPrinter) WithTimerStyle(style *Style) *SpinnerPrinter

WithTimerStyle adds a style to the SpinnerPrinter timer.

func (SpinnerPrinter) WithWriter

func (p SpinnerPrinter) WithWriter(writer io.Writer) *SpinnerPrinter

WithWriter sets the custom Writer.

type Style

type Style []Color

Style is a collection of colors. Can include foreground, background and styling (eg. Bold, Underscore, etc.) colors.

func NewStyle

func NewStyle(colors ...Color) *Style

NewStyle returns a new Style. Accepts multiple colors.

func (Style) Add

func (s Style) Add(styles ...Style) Style

Add styles to the current Style.

func (Style) Code

func (s Style) Code() string

Code convert to code string. returns like "32;45;3".

func (Style) Print

func (s Style) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Printf

func (s Style) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Printfln

func (s Style) Printfln(format string, a ...interface{})

Printfln formats according to a format specifier and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Println

func (s Style) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) RemoveColor

func (s Style) RemoveColor(colors ...Color) Style

RemoveColor removes the given colors from the Style.

func (Style) Sprint

func (s Style) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Style.

func (Style) Sprintf

func (s Style) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Style.

func (Style) Sprintfln

func (s Style) Sprintfln(format string, a ...interface{}) string

Sprintfln formats according to a format specifier and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Style.

func (Style) Sprintln

func (s Style) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Style.

func (Style) String

func (s Style) String() string

String convert to code string. returns like "32;45;3".

type TableData

type TableData [][]string

TableData is the type that contains the data of a TablePrinter.

type TablePrinter

type TablePrinter struct {
	Style                   *Style
	HasHeader               bool
	HeaderStyle             *Style
	HeaderRowSeparator      string
	HeaderRowSeparatorStyle *Style
	Separator               string
	SeparatorStyle          *Style
	RowSeparator            string
	RowSeparatorStyle       *Style
	Data                    TableData
	Boxed                   bool
	LeftAlignment           bool
	RightAlignment          bool
	Writer                  io.Writer
}

TablePrinter is able to render tables.

func (TablePrinter) Render

func (p TablePrinter) Render() error

Render prints the TablePrinter to the terminal.

func (TablePrinter) Srender

func (p TablePrinter) Srender() (string, error)

Srender renders the TablePrinter as a string.

func (TablePrinter) WithBoxed

func (p TablePrinter) WithBoxed(b ...bool) *TablePrinter

WithBoxed returns a new TablePrinter with a box around the table.

func (TablePrinter) WithCSVReader

func (p TablePrinter) WithCSVReader(reader *csv.Reader) *TablePrinter

WithCSVReader return a new TablePrinter with specified Data extracted from CSV.

func (TablePrinter) WithData

func (p TablePrinter) WithData(data [][]string) *TablePrinter

WithData returns a new TablePrinter with specific Data.

func (TablePrinter) WithHasHeader

func (p TablePrinter) WithHasHeader(b ...bool) *TablePrinter

WithHasHeader returns a new TablePrinter, where the first line is marked as a header.

func (TablePrinter) WithHeaderRowSeparator

func (p TablePrinter) WithHeaderRowSeparator(separator string) *TablePrinter

WithHeaderRowSeparator returns a new TablePrinter with a specific header HeaderRowSeparator.

func (TablePrinter) WithHeaderRowSeparatorStyle

func (p TablePrinter) WithHeaderRowSeparatorStyle(style *Style) *TablePrinter

WithHeaderRowSeparatorStyle returns a new TablePrinter with a specific header HeaderRowSeparatorStyle.

func (TablePrinter) WithHeaderStyle

func (p TablePrinter) WithHeaderStyle(style *Style) *TablePrinter

WithHeaderStyle returns a new TablePrinter with a specific HeaderStyle.

func (TablePrinter) WithLeftAlignment

func (p TablePrinter) WithLeftAlignment(b ...bool) *TablePrinter

WithLeftAlignment returns a new TablePrinter with left alignment.

func (TablePrinter) WithRightAlignment

func (p TablePrinter) WithRightAlignment(b ...bool) *TablePrinter

WithRightAlignment returns a new TablePrinter with right alignment.

func (TablePrinter) WithRowSeparator

func (p TablePrinter) WithRowSeparator(separator string) *TablePrinter

WithRowSeparator returns a new TablePrinter with a specific RowSeparator.

func (TablePrinter) WithRowSeparatorStyle

func (p TablePrinter) WithRowSeparatorStyle(style *Style) *TablePrinter

WithRowSeparatorStyle returns a new TablePrinter with a specific RowSeparatorStyle.

func (TablePrinter) WithSeparator

func (p TablePrinter) WithSeparator(separator string) *TablePrinter

WithSeparator returns a new TablePrinter with a specific separator.

func (TablePrinter) WithSeparatorStyle

func (p TablePrinter) WithSeparatorStyle(style *Style) *TablePrinter

WithSeparatorStyle returns a new TablePrinter with a specific SeparatorStyle.

func (TablePrinter) WithStyle

func (p TablePrinter) WithStyle(style *Style) *TablePrinter

WithStyle returns a new TablePrinter with a specific Style.

func (TablePrinter) WithWriter

func (p TablePrinter) WithWriter(writer io.Writer) *TablePrinter

WithWriter sets the Writer.

type TextPrinter

type TextPrinter interface {
	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	Sprint(a ...interface{}) string

	// Sprintln formats using the default formats for its operands and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	Sprintln(a ...interface{}) string

	// Sprintf formats according to a format specifier and returns the resulting string.
	Sprintf(format string, a ...interface{}) string

	// Sprintfln formats according to a format specifier and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	Sprintfln(format string, a ...interface{}) string

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Print(a ...interface{}) *TextPrinter

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Println(a ...interface{}) *TextPrinter

	// Printf formats according to a format specifier and writes to standard output.
	// It returns the number of bytes written and any write error encountered.
	Printf(format string, a ...interface{}) *TextPrinter

	// Printfln formats according to a format specifier and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Printfln(format string, a ...interface{}) *TextPrinter

	// PrintOnError prints every error which is not nil.
	// If every error is nil, nothing will be printed.
	// This can be used for simple error checking.
	PrintOnError(a ...interface{}) *TextPrinter

	// PrintOnErrorf wraps every error which is not nil and prints it.
	// If every error is nil, nothing will be printed.
	// This can be used for simple error checking.
	PrintOnErrorf(format string, a ...interface{}) *TextPrinter
}

TextPrinter contains methods to print formatted text to the console or return it as a string.

type Theme

type Theme struct {
	DefaultText             Style
	PrimaryStyle            Style
	SecondaryStyle          Style
	HighlightStyle          Style
	InfoMessageStyle        Style
	InfoPrefixStyle         Style
	SuccessMessageStyle     Style
	SuccessPrefixStyle      Style
	WarningMessageStyle     Style
	WarningPrefixStyle      Style
	ErrorMessageStyle       Style
	ErrorPrefixStyle        Style
	FatalMessageStyle       Style
	FatalPrefixStyle        Style
	DescriptionMessageStyle Style
	DescriptionPrefixStyle  Style
	ScopeStyle              Style
	ProgressbarBarStyle     Style
	ProgressbarTitleStyle   Style
	HeaderTextStyle         Style
	HeaderBackgroundStyle   Style
	SpinnerStyle            Style
	SpinnerTextStyle        Style
	TimerStyle              Style
	TableStyle              Style
	TableHeaderStyle        Style
	TableSeparatorStyle     Style
	HeatmapStyle            Style
	HeatmapHeaderStyle      Style
	HeatmapSeparatorStyle   Style
	SectionStyle            Style
	BulletListTextStyle     Style
	BulletListBulletStyle   Style
	TreeStyle               Style
	TreeTextStyle           Style
	LetterStyle             Style
	DebugMessageStyle       Style
	DebugPrefixStyle        Style
	BoxStyle                Style
	BoxTextStyle            Style
	BarLabelStyle           Style
	BarStyle                Style
	Checkmark               Checkmark
}

Theme for PTerm. Theme contains every Style used in PTerm. You can create own themes for your application or use one of the existing themes.

func (Theme) WithBarLabelStyle

func (t Theme) WithBarLabelStyle(style Style) Theme

WithBarLabelStyle returns a new theme with overridden value.

func (Theme) WithBarStyle

func (t Theme) WithBarStyle(style Style) Theme

WithBarStyle returns a new theme with overridden value.

func (Theme) WithBoxStyle

func (t Theme) WithBoxStyle(style Style) Theme

WithBoxStyle returns a new theme with overridden value.

func (Theme) WithBoxTextStyle

func (t Theme) WithBoxTextStyle(style Style) Theme

WithBoxTextStyle returns a new theme with overridden value.

func (Theme) WithBulletListBulletStyle

func (t Theme) WithBulletListBulletStyle(style Style) Theme

WithBulletListBulletStyle returns a new theme with overridden value.

func (Theme) WithBulletListTextStyle

func (t Theme) WithBulletListTextStyle(style Style) Theme

WithBulletListTextStyle returns a new theme with overridden value.

func (Theme) WithDebugMessageStyle

func (t Theme) WithDebugMessageStyle(style Style) Theme

WithDebugMessageStyle returns a new theme with overridden value.

func (Theme) WithDebugPrefixStyle

func (t Theme) WithDebugPrefixStyle(style Style) Theme

WithDebugPrefixStyle returns a new theme with overridden value.

func (Theme) WithDescriptionMessageStyle

func (t Theme) WithDescriptionMessageStyle(style Style) Theme

WithDescriptionMessageStyle returns a new theme with overridden value.

func (Theme) WithDescriptionPrefixStyle

func (t Theme) WithDescriptionPrefixStyle(style Style) Theme

WithDescriptionPrefixStyle returns a new theme with overridden value.

func (Theme) WithErrorMessageStyle

func (t Theme) WithErrorMessageStyle(style Style) Theme

WithErrorMessageStyle returns a new theme with overridden value.

func (Theme) WithErrorPrefixStyle

func (t Theme) WithErrorPrefixStyle(style Style) Theme

WithErrorPrefixStyle returns a new theme with overridden value.

func (Theme) WithFatalMessageStyle

func (t Theme) WithFatalMessageStyle(style Style) Theme

WithFatalMessageStyle returns a new theme with overridden value.

func (Theme) WithFatalPrefixStyle

func (t Theme) WithFatalPrefixStyle(style Style) Theme

WithFatalPrefixStyle returns a new theme with overridden value.

func (Theme) WithHighlightStyle

func (t Theme) WithHighlightStyle(style Style) Theme

WithHighlightStyle returns a new theme with overridden value.

func (Theme) WithInfoMessageStyle

func (t Theme) WithInfoMessageStyle(style Style) Theme

WithInfoMessageStyle returns a new theme with overridden value.

func (Theme) WithInfoPrefixStyle

func (t Theme) WithInfoPrefixStyle(style Style) Theme

WithInfoPrefixStyle returns a new theme with overridden value.

func (Theme) WithLetterStyle

func (t Theme) WithLetterStyle(style Style) Theme

WithLetterStyle returns a new theme with overridden value.

func (Theme) WithPrimaryStyle

func (t Theme) WithPrimaryStyle(style Style) Theme

WithPrimaryStyle returns a new theme with overridden value.

func (Theme) WithSecondaryStyle

func (t Theme) WithSecondaryStyle(style Style) Theme

WithSecondaryStyle returns a new theme with overridden value.

func (Theme) WithSuccessMessageStyle

func (t Theme) WithSuccessMessageStyle(style Style) Theme

WithSuccessMessageStyle returns a new theme with overridden value.

func (Theme) WithSuccessPrefixStyle

func (t Theme) WithSuccessPrefixStyle(style Style) Theme

WithSuccessPrefixStyle returns a new theme with overridden value.

func (Theme) WithTreeStyle

func (t Theme) WithTreeStyle(style Style) Theme

WithTreeStyle returns a new theme with overridden value.

func (Theme) WithTreeTextStyle

func (t Theme) WithTreeTextStyle(style Style) Theme

WithTreeTextStyle returns a new theme with overridden value.

func (Theme) WithWarningMessageStyle

func (t Theme) WithWarningMessageStyle(style Style) Theme

WithWarningMessageStyle returns a new theme with overridden value.

func (Theme) WithWarningPrefixStyle

func (t Theme) WithWarningPrefixStyle(style Style) Theme

WithWarningPrefixStyle returns a new theme with overridden value.

type TreeNode

type TreeNode struct {
	Children []TreeNode
	Text     string
}

TreeNode is used as items in a TreePrinter.

func NewTreeFromLeveledList deprecated

func NewTreeFromLeveledList(leveledListItems LeveledList) TreeNode

NewTreeFromLeveledList converts a TreeItems list to a TreeNode and returns it.

Deprecated: use putils.TreeFromLeveledList instead.

type TreePrinter

type TreePrinter struct {
	Root                 TreeNode
	TreeStyle            *Style
	TextStyle            *Style
	TopRightCornerString string
	TopRightDownString   string
	HorizontalString     string
	VerticalString       string
	RightDownLeftString  string
	Indent               int
	Writer               io.Writer
}

TreePrinter is able to render a list.

func (TreePrinter) Render

func (p TreePrinter) Render() error

Render prints the list to the terminal.

func (TreePrinter) Srender

func (p TreePrinter) Srender() (string, error)

Srender renders the list as a string.

func (TreePrinter) WithHorizontalString

func (p TreePrinter) WithHorizontalString(s string) *TreePrinter

WithHorizontalString returns a new list with a specific HorizontalString.

func (TreePrinter) WithIndent

func (p TreePrinter) WithIndent(indent int) *TreePrinter

WithIndent returns a new list with a specific amount of spacing between the levels. Indent must be at least 1.

func (TreePrinter) WithRoot

func (p TreePrinter) WithRoot(root TreeNode) *TreePrinter

WithRoot returns a new list with a specific Root.

func (TreePrinter) WithTextStyle

func (p TreePrinter) WithTextStyle(style *Style) *TreePrinter

WithTextStyle returns a new list with a specific text style.

func (TreePrinter) WithTopRightCornerString

func (p TreePrinter) WithTopRightCornerString(s string) *TreePrinter

WithTopRightCornerString returns a new list with a specific TopRightCornerString.

func (TreePrinter) WithTopRightDownStringOngoing

func (p TreePrinter) WithTopRightDownStringOngoing(s string) *TreePrinter

WithTopRightDownStringOngoing returns a new list with a specific TopRightDownString.

func (TreePrinter) WithTreeStyle

func (p TreePrinter) WithTreeStyle(style *Style) *TreePrinter

WithTreeStyle returns a new list with a specific tree style.

func (TreePrinter) WithVerticalString

func (p TreePrinter) WithVerticalString(s string) *TreePrinter

WithVerticalString returns a new list with a specific VerticalString.

func (TreePrinter) WithWriter

func (p TreePrinter) WithWriter(writer io.Writer) *TreePrinter

WithWriter sets the Writer.

Directories

Path Synopsis
_examples
Package putils contains utility functions for PTerm, to make it's usage even easier! It contains pre-made functions, that utilize PTerm, to print various stuff to the terminal.
Package putils contains utility functions for PTerm, to make it's usage even easier! It contains pre-made functions, that utilize PTerm, to print various stuff to the terminal.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL