Add support for custom levels and colorizing

Users via the `LevelColorsMap` can now map their (custom)
slog.Level => name and color.

Fixes: lmittmann#61

handler.go

@@ -24,6 +24,34 @@ See [slog.HandlerOptions] for details.
 		}),
 	)
 
+# Customize Level and Colors
+
+Options.LevelColorsMap can be used to customize the log level and colors.
+
+	w := os.Stderr
+	logger := slog.New(
+		tint.NewHandler(w, &tint.Options{
+			LevelColorsMap: tint.LevelColorsMapping{
+				slog.LevelDebug: {
+					Name:  "DEBUG",
+					Color: color.FgBlue,
+				},
+				slog.LevelInfo: {
+					Name:  "INFO",
+					Color: color.FgGreen,
+				},
+				slog.LevelWarn: {
+					Name:  "WARN",
+					Color: color.FgYellow,
+				},
+				slog.LevelError: {
+					Name:  "ERROR",
+					Color: color.FgRed,
+				},
+			},
+		}),
+	)
+
 # Automatically Enable Colors
 
 Colors are enabled by default and can be disabled using the Options.NoColor
@@ -99,6 +127,9 @@ type Options struct {
 	// See https://pkg.go.dev/log/slog#HandlerOptions for details.
 	ReplaceAttr func(groups []string, attr slog.Attr) slog.Attr
 
+	// LevelColorsMap maps slog.Level to their LevelColor
+	LevelColorsMap LevelColorsMapping
+
 	// Time format (Default: time.StampMilli)
 	TimeFormat string
 
@@ -126,6 +157,11 @@ func NewHandler(w io.Writer, opts *Options) slog.Handler {
 	if opts.TimeFormat != "" {
 		h.timeFormat = opts.TimeFormat
 	}
+
+	if len(opts.LevelColorsMap) > 0 {
+		h.levelColors = opts.LevelColorsMap.LevelColors()
+	}
+
 	h.noColor = opts.NoColor
 	return h
 }
@@ -141,6 +177,7 @@ type handler struct {
 
 	addSource   bool
 	level       slog.Leveler
+	levelColors *LevelColors
 	replaceAttr func([]string, slog.Attr) slog.Attr
 	timeFormat  string
 	noColor     bool
@@ -154,6 +191,7 @@ func (h *handler) clone() *handler {
 		w:           h.w,
 		addSource:   h.addSource,
 		level:       h.level,
+		levelColors: h.levelColors.Copy(),
 		replaceAttr: h.replaceAttr,
 		timeFormat:  h.timeFormat,
 		noColor:     h.noColor,
@@ -283,6 +321,15 @@ func (h *handler) appendTime(buf *buffer, t time.Time) {
 }
 
 func (h *handler) appendLevel(buf *buffer, level slog.Level) {
+	// check if level name is provided
+	levelColor := h.levelColors.LevelColor(level)
+	if levelColor != nil {
+		buf.WriteString(levelColor.Level(!h.noColor))
+		return
+	} else {
+		fmt.Printf("Level not found: %v\n", level)
+	}
+
 	switch {
 	case level < slog.LevelInfo:
 		buf.WriteString("DBG")

levels.go

@@ -0,0 +1,113 @@
+package tint
+
+import (
+	"log/slog"
+
+	"github.com/fatih/color"
+)
+
+// LevelColors defines the name as displayed to the user and color of a log level.
+type LevelColor struct {
+	// Name is the name of the log level
+	Name string
+	// Color is the color of the log level
+	Color      color.Attribute
+	serialized string
+	colored    bool
+}
+
+// Level returns the level name, optionally with color applied.
+func (lc *LevelColor) Level(colored bool) string {
+	if len(lc.serialized) == 0 || lc.colored != colored {
+		if colored {
+			lc.serialized = color.New(lc.Color).SprintFunc()(lc.Name)
+		} else {
+			lc.serialized = lc.Name
+		}
+	}
+	return lc.serialized
+}
+
+// Copy returns a copy of the LevelColor.
+func (lc *LevelColor) Copy() *LevelColor {
+	return &LevelColor{
+		Name:       lc.Name,
+		Color:      lc.Color,
+		serialized: lc.serialized,
+		colored:    lc.colored,
+	}
+}
+
+// LevelColorsMapping is a map of log levels to their colors and is what
+// the user defines in their configuration.
+type LevelColorsMapping map[slog.Level]LevelColor
+
+// min returns the mapped minimum index
+func (lm *LevelColorsMapping) min() int {
+	idx := 1000
+	for check, _ := range *lm {
+		if int(check) < idx {
+			idx = int(check)
+		}
+	}
+	return idx
+}
+
+// size returns the size of the slice needed to store the LevelColors
+func (lm *LevelColorsMapping) size(offset int) int {
+	maxIdx := -1000
+	for check, _ := range *lm {
+		if int(check) > maxIdx {
+			maxIdx = int(check)
+		}
+	}
+	return offset + maxIdx + 1
+}
+
+func (lm *LevelColorsMapping) offset() int {
+	min := lm.min()
+	if min < 0 {
+		min = -min
+	}
+	return min
+}
+
+func (lm *LevelColorsMapping) LevelColors() *LevelColors {
+	lcList := make([]*LevelColor, lm.size(lm.offset()))
+	for idx, lc := range *lm {
+		lcList[int(idx)+lm.offset()] = lc.Copy()
+	}
+	lc := LevelColors{
+		levels: lcList,
+		offset: lm.offset(),
+	}
+	return &lc
+}
+
+// LevelColors is our internal representation of the user-defined LevelColorsMapping.
+// We map the log levels via their slog.Level to their LevelColor using an offset
+// to ensure we can map negative level values to our slice.
+type LevelColors struct {
+	levels []*LevelColor
+	offset int
+}
+
+// LevelColor returns the LevelColor for the given log level or nil
+// indicating if the log level was not found.
+func (lc *LevelColors) LevelColor(level slog.Level) *LevelColor {
+	idx := int(level.Level()) + lc.offset
+	if len(lc.levels) < idx {
+		return &LevelColor{}
+	}
+	return lc.levels[idx]
+}
+
+// Copy returns a copy of the LevelColors.
+func (lc *LevelColors) Copy() *LevelColors {
+	lcCopy := LevelColors{
+		levels: make([]*LevelColor, len(lc.levels)),
+		offset: lc.offset,
+	}
+	copy(lcCopy.levels, lc.levels)
+	return &lcCopy
+}