Bubbletint

Bubbletint provides three ways to manage and access color palettes (tints):

1. Global Registry: A singleton approach where you initialize a default registry and set a global tint. This is useful for applications where you want to change the theme globally without passing state through every component.
2. Custom Registry: An instance-based approach where you create a specific Registry containing a subset of tints. This allows for better encapsulation and is ideal if different parts of your application need different sets of available themes.
3. Specific Tints: The simplest approach where you bypass registries entirely and use the exported Tint structs directly for static styling.

To use bubbletint in your Go project, install the v2 package using go get:

go get -u github.com/lrstanley/bubbletint/v2@latest

The credits field in the meta object accepts either a single CreditSource object or an array of CreditSource objects. This allows for flexible attribution in JSON templates.

type CreditSource struct {
	Name string `json:"name" validate:"required"`
	Link string `json:"link" validate:"required,url"`
}

Tints are fully JSON serializable.

• Unmarshalling: Supports both RGBA objects and hex strings. Hex strings are recommended for end-user ease of use.
  • RGBA format: {"r": 255, "g": 0, "b": 0, "a": 255}
  • Hex format: "#ff0000"
• Marshalling: Tints are marshalled as RGBA objects to preserve the alpha channel (which defaults to 255 for built-in tints).

The DefaultRegistry is an app-wide registry that holds a collection of pre-configured tints. To populate it with all available default tints, call NewDefaultRegistry().

Note: You should call this during your application's initialization phase before any other part of your app attempts to use the registry. While DefaultRegistry can be overridden, doing so after initialization may lead to inconsistent behavior.

package main

import "github.com/lrstanley/lrstanley/bubbletint/v2"

func init() {
	// Initialize the global registry with all default tints
	tint.NewDefaultRegistry()
}

The chromatint/v2 sub-package allows you to map bubbletint's color palettes to chroma.StyleEntries. This is useful for rendering syntax-highlighted code using a specific bubbletint theme.

import "github.com/lrstanley/bubbletint/chromatint/v2"

Use a Registry instance when you want to control exactly which tints are available and manage theme state locally. You can register additional tints at runtime and paginate through available tints using NextTint() and PreviousTint().

package main

import (
	"github.com/lrstanley/bubbletint/v2"
	"github.com/charmbracelet/lipgloss"
)

func main() {
	theme := tint.NewRegistry(
		int.TintDraculaPlus,
		int.TintCatppuccinFrappe,
		int.TintCatppuccinMocha,
		int.TintMonokaiPro,
		int.TintTinaciousDesignDark,
	)

	theme.Register(tint.TintNord) // Add more tints
	theme.SetTint(tint.TintNord)  // Set active tint
	theme.NextTint()              // Paginate

	style := lipgloss.NewStyle().
		SetForeground(theme.Current().Fg).
		Background(theme.Current().BrightGreen)
}

The Global Registry allows you to manage a single theme state across your entire application. You must initialize it with tint.NewDefaultRegistry() before use.

You can set the active tint using either the exported Tint constant or by its string ID via tint.SetTintID().

package main

import (
	"github.com/lrstanley/bubbletint/v2"
	"github.com/charmbracelet/lipgloss"
)

func main() {
	int.NewDefaultRegistry()
	int.SetTint(tint.TintDraculaPlus) // Set by constant
	int.SetTintID("dracula_plus")   // Or by ID

	// Access the current tint via tint.Current()
	style := lipgloss.NewStyle().
		SetForeground(tint.Current().Fg).
		Background(tint.Current().BrightGreen)
}

If you don't need dynamic theme switching or registries, you can use the exported Tint variables directly to style components.

package main

import (
	"github.com/lrstanley/bubbletint/v2"
	"github.com/charmbracelet/lipgloss"
)

var (
	// Using a specific tint constant directly
	statusbarStyle = lipgloss.NewStyle().
		SetForeground(tint.TintDraculaPlus.Fg).
		Background(tint.TintDraculaPlus.BrightGreen)

	// Or assigning a tint to a variable
	theme = tint.TintDraculaPlus
	style = lipgloss.NewStyle().
		SetForeground(theme.Fg).
		Background(theme.BrightGreen)
)

The Color struct represents an RGBA color and implements the standard Go color.Color interface. It can be used in any context expecting a color.Color.

Key features:

• RGBA fields: R, G, B, and A are all uint8 values.
• Hex conversion: Use Hex() to get a #RRGGBB string representation.
• JSON flexibility: When unmarshaling JSON, Color supports both an RGBA object (e.g., {"r": 255, "g": 0, "b": 0, "a": 255}) and a hex string (e.g., "#ff0000").

```go
// Example of creating a color and using its methods
color := tint.Color{R: 255, G: 0, B: 0, A: 255}

// Get RGBA values for standard library compatibility
r, g, b, a := color.RGBA()

// Get hex string
hexStr := color.Hex() // returns "#ff0000"
```埋

The Registry manages a collection of *Tint objects. You can add, remove, or list them using the following methods:

• Register(...*Tint): Adds one or more tints to the registry. This does not change the currently active tint.
• Unregister(...*Tint): Removes specific tint instances from the registry.
• UnregisterIDs(...string): Removes tints based on their unique ID strings.
• UnregisterAll(): Clears all tints from the registry.
• Tints(): Returns a slice of all registered *Tint objects, sorted alphabetically by their ID.
• TintIDs(): Returns a slice of all registered tint IDs, sorted alphabetically.

r := tint.NewRegistry(nil)

r.Register(myTint1, myTint2)
r.UnregisterIDs("tint-id-123")

allTints := r.Tints()
allIDs := r.TintIDs()