chalk

package module

v1.1.2 Latest Latest Go to latest Published: Jun 20, 2022 License: MIT Imports: 2 Imported by: 7

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/golang-demos/chalk

Links

Open Source Insights

README ¶

Chalk

Chalk is a Go Package which can be used for making terminal output more vibrant with text colors, text styles and background colors.

Documentation

Check out godoc for some example usage: http://godoc.org/github.com/golang-demos/chalk

Usage

Instructions

Sample Code

package main

import (
	"fmt"

	"github.com/golang-demos/chalk"
)

func main() {
	fmt.Println(chalk.BlackLight(), "chalk.BlackLight()", chalk.Reset())

	fmt.Println(chalk.Blue(), "chalk.Blue()", chalk.Reset())

	fmt.Println(chalk.Underline(), "chalk.Underline()", chalk.Reset())

	fmt.Println(chalk.Red().Italic(), "chalk.Red().Italic()", chalk.Reset())
	fmt.Println(chalk.Green().Strikethrough(), "chalk.Green().Strikethrough()", chalk.Reset())
	fmt.Println(chalk.Cyan().Underline().BgBlackLight(), "chalk.Cyan().Underline().BgBlackLight()", chalk.Reset())
	fmt.Println(chalk.Yellow().BgRed().Inverse(), "chalk.Yellow().BgRed().Inverse()", chalk.Reset())

	// For Existing Code
	fmt.Print(chalk.Green())
	fmt.Prinln("Data Sent Successfully")
	fmt.Print(chalk.Reset())
}

Source

https://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html

Author

Vinay Jeurkar

Documentation ¶

Overview ¶

Chalk is a Go Package which can be used for making terminal output more vibrant with text colors, text styles and background colors. The styling factors are: - Text Color - Text Style - Background Color

Text Color ¶

There are sixteen Colors. You can use them as follow :

fmt.Println(chalk.Black(), "Black", chalk.Reset())
fmt.Println(chalk.BlackLight(), "BlackLight", chalk.Reset())
fmt.Println(chalk.Red(), "Red", chalk.Reset())
fmt.Println(chalk.RedLight(), "RedLight", chalk.Reset())
fmt.Println(chalk.Green(), "Green", chalk.Reset())
fmt.Println(chalk.GreenLight(), "GreenLight", chalk.Reset())
fmt.Println(chalk.Yellow(), "Yellow", chalk.Reset())
fmt.Println(chalk.YellowLight(), "YellowLight", chalk.Reset())
fmt.Println(chalk.Blue(), "Blue", chalk.Reset())
fmt.Println(chalk.BlueLight(), "BlueLight", chalk.Reset())
fmt.Println(chalk.Magenta(), "Magenta", chalk.Reset())
fmt.Println(chalk.MagentaLight(), "MagentaLight", chalk.Reset())
fmt.Println(chalk.Cyan(), "Cyan", chalk.Reset())
fmt.Println(chalk.CyanLight(), "CyanLight", chalk.Reset())
fmt.Println(chalk.White(), "White", chalk.Reset())
fmt.Println(chalk.WhiteLight(), "WhiteLight", chalk.Reset())

Text Style ¶

There are seven text styles. You can use them as follow:

fmt.Println(chalk.Bold(), "Bold", chalk.Reset())
fmt.Println(chalk.Dim(), "Dim", chalk.Reset())
fmt.Println(chalk.Italic(), "Italic", chalk.Reset())
fmt.Println(chalk.Underline(), "Underline", chalk.Reset())
fmt.Println(chalk.Inverse(), "Inverse", chalk.Reset())
fmt.Println(chalk.Hidden(), "Hidden", chalk.Reset())
fmt.Println(chalk.Strikethrough(), "Strikethrough", chalk.Reset())

Background Color ¶

There are sixteen background colors. You can use them as follow:

fmt.Println(chalk.BgBlack(), "BgBlack", chalk.Reset())
fmt.Println(chalk.BgBlackLight(), "BgBlackLight", chalk.Reset())
fmt.Println(chalk.BgRed(), "BgRed", chalk.Reset())
fmt.Println(chalk.BgRedLight(), "BgRedLight", chalk.Reset())
fmt.Println(chalk.BgGreen(), "BgGreen", chalk.Reset())
fmt.Println(chalk.BgGreenLight(), "BgGreenLight", chalk.Reset())
fmt.Println(chalk.BgYellow(), "BgYellow", chalk.Reset())
fmt.Println(chalk.BgYellowLight(), "BgYellowLight", chalk.Reset())
fmt.Println(chalk.BgBlue(), "BgBlue", chalk.Reset())
fmt.Println(chalk.BgBlueLight(), "BgBlueLight", chalk.Reset())
fmt.Println(chalk.BgMagenta(), "BgMagenta", chalk.Reset())
fmt.Println(chalk.BgMagentaLight(), "BgMagentaLight", chalk.Reset())
fmt.Println(chalk.BgCyan(), "BgCyan", chalk.Reset())
fmt.Println(chalk.BgCyanLight(), "BgCyanLight", chalk.Reset())
fmt.Println(chalk.BgWhite(), "BgWhite", chalk.Reset())
fmt.Println(chalk.BgWhiteLight(), "BgWhiteLight", chalk.Reset())

You can use above functions in combinations. Following are some examples to refer:

fmt.Println(chalk.Red().Italic(), "Red + Italic", chalk.Reset())
fmt.Println(chalk.Green().Strikethrough(), "Green + Strikethrough", chalk.Reset())
fmt.Println(chalk.Cyan().Underline().BgBlackLight(), "Cyan + Underline + BgBlackLight", chalk.Reset())
fmt.Println(chalk.Yellow().BgRed().Inverse(), "Yellow + BgRed + Inverse", chalk.Reset())

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	// Text Colors
	Black   = func(msgs ...interface{}) *Color { return newColor().Black(msgs...) }
	Red     = func(msgs ...interface{}) *Color { return newColor().Red(msgs...) }
	Green   = func(msgs ...interface{}) *Color { return newColor().Green(msgs...) }
	Yellow  = func(msgs ...interface{}) *Color { return newColor().Yellow(msgs...) }
	Blue    = func(msgs ...interface{}) *Color { return newColor().Blue(msgs...) }
	Magenta = func(msgs ...interface{}) *Color { return newColor().Magenta(msgs...) }
	Cyan    = func(msgs ...interface{}) *Color { return newColor().Cyan(msgs...) }
	White   = func(msgs ...interface{}) *Color { return newColor().White(msgs...) }

	// Text Light Colors
	BlackLight   = func(msgs ...interface{}) *Color { return newColor().BlackLight(msgs...) }
	RedLight     = func(msgs ...interface{}) *Color { return newColor().RedLight(msgs...) }
	GreenLight   = func(msgs ...interface{}) *Color { return newColor().GreenLight(msgs...) }
	YellowLight  = func(msgs ...interface{}) *Color { return newColor().YellowLight(msgs...) }
	BlueLight    = func(msgs ...interface{}) *Color { return newColor().BlueLight(msgs...) }
	MagentaLight = func(msgs ...interface{}) *Color { return newColor().MagentaLight(msgs...) }
	CyanLight    = func(msgs ...interface{}) *Color { return newColor().CyanLight(msgs...) }
	WhiteLight   = func(msgs ...interface{}) *Color { return newColor().WhiteLight(msgs...) }

	// Text Styles
	Bold          = func(msgs ...interface{}) *Color { return newColor().Bold(msgs...) }
	Dim           = func(msgs ...interface{}) *Color { return newColor().Dim(msgs...) }
	Italic        = func(msgs ...interface{}) *Color { return newColor().Italic(msgs...) }
	Underline     = func(msgs ...interface{}) *Color { return newColor().Underline(msgs...) }
	Inverse       = func(msgs ...interface{}) *Color { return newColor().Inverse(msgs...) }
	Hidden        = func(msgs ...interface{}) *Color { return newColor().Hidden(msgs...) }
	Strikethrough = func(msgs ...interface{}) *Color { return newColor().Strikethrough(msgs...) }

	// Background Colors
	BgBlack   = func(msgs ...interface{}) *Color { return newColor().BgBlack(msgs...) }
	BgRed     = func(msgs ...interface{}) *Color { return newColor().BgRed(msgs...) }
	BgGreen   = func(msgs ...interface{}) *Color { return newColor().BgGreen(msgs...) }
	BgYellow  = func(msgs ...interface{}) *Color { return newColor().BgYellow(msgs...) }
	BgBlue    = func(msgs ...interface{}) *Color { return newColor().BgBlue(msgs...) }
	BgMagenta = func(msgs ...interface{}) *Color { return newColor().BgMagenta(msgs...) }
	BgCyan    = func(msgs ...interface{}) *Color { return newColor().BgCyan(msgs...) }
	BgWhite   = func(msgs ...interface{}) *Color { return newColor().BgWhite(msgs...) }

	BgBlackLight   = func(msgs ...interface{}) *Color { return newColor().BgBlackLight(msgs...) }
	BgRedLight     = func(msgs ...interface{}) *Color { return newColor().BgRedLight(msgs...) }
	BgGreenLight   = func(msgs ...interface{}) *Color { return newColor().BgGreenLight(msgs...) }
	BgYellowLight  = func(msgs ...interface{}) *Color { return newColor().BgYellowLight(msgs...) }
	BgBlueLight    = func(msgs ...interface{}) *Color { return newColor().BgBlueLight(msgs...) }
	BgMagentaLight = func(msgs ...interface{}) *Color { return newColor().BgMagentaLight(msgs...) }
	BgCyanLight    = func(msgs ...interface{}) *Color { return newColor().BgCyanLight(msgs...) }
	BgWhiteLight   = func(msgs ...interface{}) *Color { return newColor().BgWhiteLight(msgs...) }
)

Functions ¶

func Reset ¶

func Reset() string

For all reset. BackgroundColor and TextColor

Types ¶

type Color ¶

type Color struct {
	// contains filtered or unexported fields
}

func (*Color) BgBlack ¶

func (c *Color) BgBlack(msgs ...interface{}) *Color

Background Colors

func (*Color) BgBlackLight ¶

func (c *Color) BgBlackLight(msgs ...interface{}) *Color

func (*Color) BgBlue ¶

func (c *Color) BgBlue(msgs ...interface{}) *Color

func (*Color) BgBlueLight ¶

func (c *Color) BgBlueLight(msgs ...interface{}) *Color

func (*Color) BgCyan ¶

func (c *Color) BgCyan(msgs ...interface{}) *Color

func (*Color) BgCyanLight ¶

func (c *Color) BgCyanLight(msgs ...interface{}) *Color

func (*Color) BgGreen ¶

func (c *Color) BgGreen(msgs ...interface{}) *Color

func (*Color) BgGreenLight ¶

func (c *Color) BgGreenLight(msgs ...interface{}) *Color

func (*Color) BgMagenta ¶

func (c *Color) BgMagenta(msgs ...interface{}) *Color

func (*Color) BgMagentaLight ¶

func (c *Color) BgMagentaLight(msgs ...interface{}) *Color

func (*Color) BgRed ¶

func (c *Color) BgRed(msgs ...interface{}) *Color

func (*Color) BgRedLight ¶

func (c *Color) BgRedLight(msgs ...interface{}) *Color

func (*Color) BgWhite ¶

func (c *Color) BgWhite(msgs ...interface{}) *Color

func (*Color) BgWhiteLight ¶

func (c *Color) BgWhiteLight(msgs ...interface{}) *Color

func (*Color) BgYellow ¶

func (c *Color) BgYellow(msgs ...interface{}) *Color

func (*Color) BgYellowLight ¶

func (c *Color) BgYellowLight(msgs ...interface{}) *Color

func (*Color) Black ¶

func (c *Color) Black(msgs ...interface{}) *Color

Colors

func (*Color) BlackLight ¶

func (c *Color) BlackLight(msgs ...interface{}) *Color

func (*Color) Blue ¶

func (c *Color) Blue(msgs ...interface{}) *Color

func (*Color) BlueLight ¶

func (c *Color) BlueLight(msgs ...interface{}) *Color

func (*Color) Bold ¶

func (c *Color) Bold(msgs ...interface{}) *Color

Text Styles

func (*Color) Cyan ¶

func (c *Color) Cyan(msgs ...interface{}) *Color

func (*Color) CyanLight ¶

func (c *Color) CyanLight(msgs ...interface{}) *Color

func (*Color) Dim ¶

func (c *Color) Dim(msgs ...interface{}) *Color

func (*Color) Green ¶

func (c *Color) Green(msgs ...interface{}) *Color

func (*Color) GreenLight ¶

func (c *Color) GreenLight(msgs ...interface{}) *Color

func (*Color) Hidden ¶

func (c *Color) Hidden(msgs ...interface{}) *Color

func (*Color) Inverse ¶

func (c *Color) Inverse(msgs ...interface{}) *Color

func (*Color) Italic ¶

func (c *Color) Italic(msgs ...interface{}) *Color

func (*Color) Magenta ¶

func (c *Color) Magenta(msgs ...interface{}) *Color

func (*Color) MagentaLight ¶

func (c *Color) MagentaLight(msgs ...interface{}) *Color

func (*Color) Red ¶

func (c *Color) Red(msgs ...interface{}) *Color

func (*Color) RedLight ¶

func (c *Color) RedLight(msgs ...interface{}) *Color

func (*Color) SetText ¶ added in v1.1.2

func (c *Color) SetText(msgs []interface{})

func (*Color) Strikethrough ¶

func (c *Color) Strikethrough(msgs ...interface{}) *Color

func (Color) String ¶

func (c Color) String() string

func (*Color) Underline ¶

func (c *Color) Underline(msgs ...interface{}) *Color

func (*Color) White ¶

func (c *Color) White(msgs ...interface{}) *Color

func (*Color) WhiteLight ¶

func (c *Color) WhiteLight(msgs ...interface{}) *Color

func (*Color) Yellow ¶

func (c *Color) Yellow(msgs ...interface{}) *Color

func (*Color) YellowLight ¶

func (c *Color) YellowLight(msgs ...interface{}) *Color

type PrintableText ¶ added in v1.1.2

type PrintableText interface {
	String() string
}

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
examples

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL