feat: rename 'theme' to 'flavour' to keep consistency (#7)

* refactor: Rename 'theme' to 'flavour'

* fix: Make `Theme` a type alias of `Flavour`

Author: kkrypt0nn

README.md

@@ -17,7 +17,7 @@
 
 1. `go get github.com/catppuccin/go`
 2. Add an`import catppuccin "github.com/catppuccin/go"` to your file
-3. Use the theme variants as you wish.
+3. Use the flavours as you wish.
 
 ## 🙋 FAQ (optional)
 

_examples/main.go

@@ -9,45 +9,45 @@ import (
 
 func main() {
 	fmt.Println()
-	for _, theme := range []catppuccin.Theme{
+	for _, flavour := range []catppuccin.Flavour{
 		catppuccin.Mocha(),
 		catppuccin.Frappe(),
 		catppuccin.Macchiato(),
 		catppuccin.Latte(),
 	} {
 
-		fmt.Println(lipgloss.NewStyle().Bold(true).Render(theme.Name() + ":"))
-		format("rosewater", theme.Rosewater(), theme.Base())
-		format("flamingo", theme.Flamingo(), theme.Base())
-		format("pink", theme.Pink(), theme.Base())
-		format("mauve", theme.Mauve(), theme.Base())
-		format("red", theme.Red(), theme.Base())
+		fmt.Println(lipgloss.NewStyle().Bold(true).Render(flavour.Name() + ":"))
+		format("rosewater", flavour.Rosewater(), flavour.Base())
+		format("flamingo", flavour.Flamingo(), flavour.Base())
+		format("pink", flavour.Pink(), flavour.Base())
+		format("mauve", flavour.Mauve(), flavour.Base())
+		format("red", flavour.Red(), flavour.Base())
 		fmt.Println()
-		format("maroon", theme.Maroon(), theme.Base())
-		format("peach", theme.Peach(), theme.Base())
-		format("yellow", theme.Yellow(), theme.Base())
-		format("green", theme.Green(), theme.Base())
-		format("teal", theme.Teal(), theme.Base())
+		format("maroon", flavour.Maroon(), flavour.Base())
+		format("peach", flavour.Peach(), flavour.Base())
+		format("yellow", flavour.Yellow(), flavour.Base())
+		format("green", flavour.Green(), flavour.Base())
+		format("teal", flavour.Teal(), flavour.Base())
 		fmt.Println()
-		format("sky", theme.Sky(), theme.Base())
-		format("sapphire", theme.Sapphire(), theme.Base())
-		format("blue", theme.Blue(), theme.Base())
-		format("lavender", theme.Lavender(), theme.Base())
-		format("text", theme.Text(), theme.Base())
+		format("sky", flavour.Sky(), flavour.Base())
+		format("sapphire", flavour.Sapphire(), flavour.Base())
+		format("blue", flavour.Blue(), flavour.Base())
+		format("lavender", flavour.Lavender(), flavour.Base())
+		format("text", flavour.Text(), flavour.Base())
 		fmt.Println()
-		format("subtext1", theme.Subtext1(), theme.Base())
-		format("subtext0", theme.Subtext0(), theme.Base())
-		format("overlay2", theme.Overlay2(), theme.Base())
-		format("overlay1", theme.Overlay1(), theme.Base())
-		format("overlay0", theme.Overlay0(), theme.Text())
+		format("subtext1", flavour.Subtext1(), flavour.Base())
+		format("subtext0", flavour.Subtext0(), flavour.Base())
+		format("overlay2", flavour.Overlay2(), flavour.Base())
+		format("overlay1", flavour.Overlay1(), flavour.Base())
+		format("overlay0", flavour.Overlay0(), flavour.Text())
 		fmt.Println()
-		format("surface2", theme.Surface2(), theme.Text())
-		format("surface1", theme.Surface1(), theme.Text())
-		format("surface0", theme.Surface0(), theme.Text())
-		format("crust", theme.Crust(), theme.Text())
-		format("mantle", theme.Mantle(), theme.Text())
+		format("surface2", flavour.Surface2(), flavour.Text())
+		format("surface1", flavour.Surface1(), flavour.Text())
+		format("surface0", flavour.Surface0(), flavour.Text())
+		format("crust", flavour.Crust(), flavour.Text())
+		format("mantle", flavour.Mantle(), flavour.Text())
 		fmt.Println()
-		format("base", theme.Base(), theme.Text())
+		format("base", flavour.Base(), flavour.Text())
 		fmt.Println()
 		fmt.Println()
 	}

frappe.go

@@ -3,8 +3,8 @@ package catppuccingo
 // frappe variant.
 type frappe struct{}
 
-// Frappe theme variant.
-var Frappe Theme = frappe{}
+// Frappe flavour variant.
+var Frappe Flavour = frappe{}
 
 func (frappe) Name() string { return "frappe" }
 

latte.go

@@ -3,8 +3,8 @@ package catppuccingo
 // latte variant.
 type latte struct{}
 
-// Latte theme variant.
-var Latte Theme = latte{}
+// Latte flavour variant.
+var Latte Flavour = latte{}
 
 func (latte) Name() string { return "latte" }
 

macchiato.go

@@ -3,8 +3,8 @@ package catppuccingo
 // macchiato variant.
 type macchiato struct{}
 
-// Macchiato theme variant.
-var Macchiato Theme = macchiato{}
+// Macchiato flavour variant.
+var Macchiato Flavour = macchiato{}
 
 func (macchiato) Name() string { return "macchiato" }
 

main.go

@@ -2,8 +2,8 @@ package catppuccingo
 
 import "image/color"
 
-// Theme is an interface implemented by all Catppuccin variations.
-type Theme interface {
+// Flavour is an interface implemented by all Catppuccin variations.
+type Flavour interface {
 	Rosewater() Color
 	Flamingo() Color
 	Pink() Color
@@ -33,6 +33,9 @@ type Theme interface {
 	Name() string
 }
 
+// Theme is a type alias of Flavour to keep compatibility with previous versions.
+type Theme = Flavour
+
 // Color is a color in Hex, RGB, and HSL.
 type Color struct {
 	Hex string

main_test.go

@@ -4,40 +4,40 @@ import (
 	"testing"
 )
 
-func TestThemes(t *testing.T) {
-	for _, theme := range []Theme{
+func TestFlavours(t *testing.T) {
+	for _, flavour := range []Flavour{
 		Mocha,
 		Frappe,
 		Macchiato,
 		Latte,
 	} {
-		t.Run(theme.Name(), func(t *testing.T) {
-			requireNotEmpty(t, theme.Rosewater())
-			requireNotEmpty(t, theme.Flamingo())
-			requireNotEmpty(t, theme.Pink())
-			requireNotEmpty(t, theme.Mauve())
-			requireNotEmpty(t, theme.Red())
-			requireNotEmpty(t, theme.Maroon())
-			requireNotEmpty(t, theme.Peach())
-			requireNotEmpty(t, theme.Yellow())
-			requireNotEmpty(t, theme.Green())
-			requireNotEmpty(t, theme.Teal())
-			requireNotEmpty(t, theme.Sky())
-			requireNotEmpty(t, theme.Sapphire())
-			requireNotEmpty(t, theme.Blue())
-			requireNotEmpty(t, theme.Lavender())
-			requireNotEmpty(t, theme.Text())
-			requireNotEmpty(t, theme.Subtext1())
-			requireNotEmpty(t, theme.Subtext0())
-			requireNotEmpty(t, theme.Overlay2())
-			requireNotEmpty(t, theme.Overlay1())
-			requireNotEmpty(t, theme.Overlay0())
-			requireNotEmpty(t, theme.Surface2())
-			requireNotEmpty(t, theme.Surface1())
-			requireNotEmpty(t, theme.Surface0())
-			requireNotEmpty(t, theme.Crust())
-			requireNotEmpty(t, theme.Mantle())
-			requireNotEmpty(t, theme.Base())
+		t.Run(flavour.Name(), func(t *testing.T) {
+			requireNotEmpty(t, flavour.Rosewater())
+			requireNotEmpty(t, flavour.Flamingo())
+			requireNotEmpty(t, flavour.Pink())
+			requireNotEmpty(t, flavour.Mauve())
+			requireNotEmpty(t, flavour.Red())
+			requireNotEmpty(t, flavour.Maroon())
+			requireNotEmpty(t, flavour.Peach())
+			requireNotEmpty(t, flavour.Yellow())
+			requireNotEmpty(t, flavour.Green())
+			requireNotEmpty(t, flavour.Teal())
+			requireNotEmpty(t, flavour.Sky())
+			requireNotEmpty(t, flavour.Sapphire())
+			requireNotEmpty(t, flavour.Blue())
+			requireNotEmpty(t, flavour.Lavender())
+			requireNotEmpty(t, flavour.Text())
+			requireNotEmpty(t, flavour.Subtext1())
+			requireNotEmpty(t, flavour.Subtext0())
+			requireNotEmpty(t, flavour.Overlay2())
+			requireNotEmpty(t, flavour.Overlay1())
+			requireNotEmpty(t, flavour.Overlay0())
+			requireNotEmpty(t, flavour.Surface2())
+			requireNotEmpty(t, flavour.Surface1())
+			requireNotEmpty(t, flavour.Surface0())
+			requireNotEmpty(t, flavour.Crust())
+			requireNotEmpty(t, flavour.Mantle())
+			requireNotEmpty(t, flavour.Base())
 		})
 	}
 }

mocha.go

@@ -2,8 +2,8 @@ package catppuccingo
 
 type mocha struct{}
 
-// Mocha theme variant.
-var Mocha Theme = mocha{}
+// Mocha flavour variant.
+var Mocha Flavour = mocha{}
 
 func (mocha) Name() string { return "mocha" }