2021-03-02 02:29:00 +03:00
|
|
|
package lipgloss
|
|
|
|
|
2021-03-04 03:23:52 +03:00
|
|
|
import (
|
2022-10-06 19:52:12 +03:00
|
|
|
"strconv"
|
2021-04-05 16:39:11 +03:00
|
|
|
|
2021-03-04 03:23:52 +03:00
|
|
|
"github.com/muesli/termenv"
|
|
|
|
)
|
2021-03-02 02:29:00 +03:00
|
|
|
|
2022-06-28 20:28:35 +03:00
|
|
|
// TerminalColor is a color intended to be rendered in the terminal.
|
2021-03-31 05:19:38 +03:00
|
|
|
type TerminalColor interface {
|
2022-10-03 20:11:44 +03:00
|
|
|
color(*Renderer) termenv.Color
|
2022-10-06 19:52:12 +03:00
|
|
|
RGBA() (r, g, b, a uint32)
|
2021-03-02 02:29:00 +03:00
|
|
|
}
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
var noColor = NoColor{}
|
|
|
|
|
2021-03-02 02:29:00 +03:00
|
|
|
// NoColor is used to specify the absence of color styling. When this is active
|
|
|
|
// foreground colors will be rendered with the terminal's default text color,
|
|
|
|
// and background colors will not be drawn at all.
|
|
|
|
//
|
|
|
|
// Example usage:
|
|
|
|
//
|
2022-08-24 19:05:18 +03:00
|
|
|
// var style = someStyle.Copy().Background(lipgloss.NoColor{})
|
2021-03-18 21:34:39 +03:00
|
|
|
type NoColor struct{}
|
2021-03-02 02:29:00 +03:00
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (NoColor) color(*Renderer) termenv.Color {
|
|
|
|
return termenv.NoColor{}
|
2021-03-31 05:28:54 +03:00
|
|
|
}
|
|
|
|
|
2022-10-06 19:52:12 +03:00
|
|
|
// RGBA returns the RGBA value of this color. Because we have to return
|
|
|
|
// something, despite this color being the absence of color, we're returning
|
|
|
|
// black with 100% opacity.
|
|
|
|
//
|
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
|
|
|
//
|
|
|
|
// Deprecated.
|
|
|
|
func (n NoColor) RGBA() (r, g, b, a uint32) {
|
2023-07-24 18:50:04 +03:00
|
|
|
return 0x0, 0x0, 0x0, 0xFFFF //nolint:gomnd
|
2022-10-06 19:52:12 +03:00
|
|
|
}
|
|
|
|
|
2021-03-02 02:29:00 +03:00
|
|
|
// Color specifies a color by hex or ANSI value. For example:
|
|
|
|
//
|
2022-08-24 19:05:18 +03:00
|
|
|
// ansiColor := lipgloss.Color("21")
|
|
|
|
// hexColor := lipgloss.Color("#0000ff")
|
2021-03-02 02:29:00 +03:00
|
|
|
type Color string
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (c Color) color(r *Renderer) termenv.Color {
|
|
|
|
return r.ColorProfile().Color(string(c))
|
2021-03-31 05:28:54 +03:00
|
|
|
}
|
|
|
|
|
2022-10-06 19:52:12 +03:00
|
|
|
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
|
|
|
// interface. Note that on error we return black with 100% opacity, or:
|
|
|
|
//
|
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
|
|
|
//
|
|
|
|
// Deprecated.
|
|
|
|
func (c Color) RGBA() (r, g, b, a uint32) {
|
|
|
|
return termenv.ConvertToRGB(c.color(renderer)).RGBA()
|
|
|
|
}
|
|
|
|
|
2022-06-28 20:28:35 +03:00
|
|
|
// ANSIColor is a color specified by an ANSI color value. It's merely syntactic
|
|
|
|
// sugar for the more general Color function. Invalid colors will render as
|
|
|
|
// black.
|
|
|
|
//
|
|
|
|
// Example usage:
|
|
|
|
//
|
|
|
|
// // These two statements are equivalent.
|
|
|
|
// colorA := lipgloss.ANSIColor(21)
|
|
|
|
// colorB := lipgloss.Color("21")
|
|
|
|
type ANSIColor uint
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (ac ANSIColor) color(r *Renderer) termenv.Color {
|
2022-10-06 19:52:12 +03:00
|
|
|
return Color(strconv.FormatUint(uint64(ac), 10)).color(r)
|
|
|
|
}
|
|
|
|
|
|
|
|
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
|
|
|
// interface. Note that on error we return black with 100% opacity, or:
|
|
|
|
//
|
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
|
|
|
//
|
|
|
|
// Deprecated.
|
|
|
|
func (ac ANSIColor) RGBA() (r, g, b, a uint32) {
|
|
|
|
cf := Color(strconv.FormatUint(uint64(ac), 10))
|
|
|
|
return cf.RGBA()
|
2022-06-28 20:28:35 +03:00
|
|
|
}
|
|
|
|
|
2021-03-26 17:36:23 +03:00
|
|
|
// AdaptiveColor provides color options for light and dark backgrounds. The
|
2022-02-06 02:35:33 +03:00
|
|
|
// appropriate color will be returned at runtime based on the darkness of the
|
2021-03-31 05:28:54 +03:00
|
|
|
// terminal background color.
|
2021-03-02 02:29:00 +03:00
|
|
|
//
|
|
|
|
// Example usage:
|
|
|
|
//
|
2022-08-24 19:05:18 +03:00
|
|
|
// color := lipgloss.AdaptiveColor{Light: "#0000ff", Dark: "#000099"}
|
2021-03-02 02:29:00 +03:00
|
|
|
type AdaptiveColor struct {
|
|
|
|
Light string
|
|
|
|
Dark string
|
|
|
|
}
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (ac AdaptiveColor) color(r *Renderer) termenv.Color {
|
|
|
|
if r.HasDarkBackground() {
|
|
|
|
return Color(ac.Dark).color(r)
|
2021-03-02 02:29:00 +03:00
|
|
|
}
|
2022-10-03 20:11:44 +03:00
|
|
|
return Color(ac.Light).color(r)
|
2021-03-26 22:57:47 +03:00
|
|
|
}
|
2022-07-06 02:11:11 +03:00
|
|
|
|
2022-10-06 19:52:12 +03:00
|
|
|
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
|
|
|
// interface. Note that on error we return black with 100% opacity, or:
|
|
|
|
//
|
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
|
|
|
//
|
|
|
|
// Deprecated.
|
|
|
|
func (ac AdaptiveColor) RGBA() (r, g, b, a uint32) {
|
|
|
|
return termenv.ConvertToRGB(ac.color(renderer)).RGBA()
|
|
|
|
}
|
|
|
|
|
2022-08-30 23:38:15 +03:00
|
|
|
// CompleteColor specifies exact values for truecolor, ANSI256, and ANSI color
|
2022-11-08 12:55:11 +03:00
|
|
|
// profiles. Automatic color degradation will not be performed.
|
2022-08-30 23:38:15 +03:00
|
|
|
type CompleteColor struct {
|
|
|
|
TrueColor string
|
|
|
|
ANSI256 string
|
|
|
|
ANSI string
|
|
|
|
}
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (c CompleteColor) color(r *Renderer) termenv.Color {
|
|
|
|
p := r.ColorProfile()
|
2023-07-24 18:50:04 +03:00
|
|
|
switch p { //nolint:exhaustive
|
2022-08-30 23:38:15 +03:00
|
|
|
case termenv.TrueColor:
|
2022-10-03 20:11:44 +03:00
|
|
|
return p.Color(c.TrueColor)
|
2022-08-30 23:38:15 +03:00
|
|
|
case termenv.ANSI256:
|
2022-10-03 20:11:44 +03:00
|
|
|
return p.Color(c.ANSI256)
|
2022-08-30 23:38:15 +03:00
|
|
|
case termenv.ANSI:
|
2022-10-03 20:11:44 +03:00
|
|
|
return p.Color(c.ANSI)
|
2022-08-30 23:38:15 +03:00
|
|
|
default:
|
2022-10-03 20:11:44 +03:00
|
|
|
return termenv.NoColor{}
|
2022-08-30 23:38:15 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
|
|
|
// interface. Note that on error we return black with 100% opacity, or:
|
|
|
|
//
|
2022-09-30 05:59:08 +03:00
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
2022-10-06 19:52:12 +03:00
|
|
|
// CompleteAdaptiveColor specifies exact values for truecolor, ANSI256, and ANSI color
|
|
|
|
//
|
|
|
|
// Deprecated.
|
2022-08-30 23:38:15 +03:00
|
|
|
func (c CompleteColor) RGBA() (r, g, b, a uint32) {
|
2022-10-06 19:52:12 +03:00
|
|
|
return termenv.ConvertToRGB(c.color(renderer)).RGBA()
|
2022-08-30 23:38:15 +03:00
|
|
|
}
|
|
|
|
|
2023-03-12 13:04:42 +03:00
|
|
|
// CompleteAdaptiveColor specifies exact values for truecolor, ANSI256, and ANSI color
|
2022-08-30 23:38:15 +03:00
|
|
|
// profiles, with separate options for light and dark backgrounds. Automatic
|
2022-11-08 12:55:11 +03:00
|
|
|
// color degradation will not be performed.
|
2022-08-30 23:38:15 +03:00
|
|
|
type CompleteAdaptiveColor struct {
|
|
|
|
Light CompleteColor
|
|
|
|
Dark CompleteColor
|
|
|
|
}
|
|
|
|
|
2022-10-03 20:11:44 +03:00
|
|
|
func (cac CompleteAdaptiveColor) color(r *Renderer) termenv.Color {
|
|
|
|
if r.HasDarkBackground() {
|
|
|
|
return cac.Dark.color(r)
|
2022-08-30 23:38:15 +03:00
|
|
|
}
|
2022-10-03 20:11:44 +03:00
|
|
|
return cac.Light.color(r)
|
2022-07-06 02:11:11 +03:00
|
|
|
}
|
2022-10-06 19:52:12 +03:00
|
|
|
|
|
|
|
// RGBA returns the RGBA value of this color. This satisfies the Go Color
|
|
|
|
// interface. Note that on error we return black with 100% opacity, or:
|
|
|
|
//
|
|
|
|
// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
|
|
|
|
//
|
|
|
|
// Deprecated.
|
|
|
|
func (cac CompleteAdaptiveColor) RGBA() (r, g, b, a uint32) {
|
|
|
|
return termenv.ConvertToRGB(cac.color(renderer)).RGBA()
|
|
|
|
}
|