feat: use context to store values

context.go

@@ -45,44 +45,76 @@ type Context interface {
 	// what else?
 }
 
+type contextKey struct{ string }
+
+var (
+	// ContextKeyColorProfile is the key used to store the terminal's color
+	// profile in the context.
+	ContextKeyColorProfile = contextKey{"color-profile"}
+
+	// ContextKeyKittyKeyboardFlags is the key used to store the terminal's Kitty
+	// Keyboard Protocol flags in the context.
+	ContextKeyKittyKeyboardFlags = contextKey{"kitty-keyboard-flags"}
+
+	// ContextKeyBackgroundColor is the key used to store the terminal's background
+	// color in the context.
+	ContextKeyBackgroundColor = contextKey{"background-color"}
+
+	// ContextKeyHasLightBackground is the key used to store whether the terminal
+	// has a light background in the context.
+	ContextKeyHasLightBackground = contextKey{"has-light-background"}
+)
+
 type teaContext struct {
 	context.Context
 
-	profile         lipgloss.Profile
-	kittyFlags      int
-	backgroundColor color.Color
-	hasLightBg      bool // cached value
-
 	values map[interface{}]interface{}
 	mtx    sync.Mutex
 }
 
-func newContext(ctx context.Context) *teaContext {
+// newContext returns a new teaContext and a cancel function. It wraps the
+// provided context with a new context that can be canceled.
+func newContext(ctx context.Context) (*teaContext, context.CancelFunc) {
 	c := new(teaContext)
-	c.Context = ctx
-	c.kittyFlags = -1
+	var cancel context.CancelFunc
+	c.Context, cancel = context.WithCancel(ctx)
 	c.values = make(map[interface{}]interface{})
-	return c
+	c.SetValue(ContextKeyKittyKeyboardFlags, -1)
+	return c, cancel
 }
 
 func (c *teaContext) BackgroundColor() color.Color {
-	return c.backgroundColor
+	if bg, ok := c.Value(ContextKeyBackgroundColor).(color.Color); ok {
+		return bg
+	}
+	return nil
 }
 
 func (c *teaContext) HasLightBackground() bool {
-	return c.hasLightBg
+	if v, ok := c.Value(ContextKeyHasLightBackground).(bool); ok {
+		return v
+	}
+	return false
 }
 
 func (c *teaContext) SupportsEnhancedKeyboard() bool {
-	return c.kittyFlags >= 0
+	if v, ok := c.Value(ContextKeyKittyKeyboardFlags).(int); ok {
+		return v >= 0
+	}
+	return false
 }
 
 func (c *teaContext) NewStyle() lipgloss.Style {
-	return lipgloss.NewStyle().ColorProfile(c.profile).HasLightBackground(c.hasLightBg)
+	return lipgloss.NewStyle().
+		ColorProfile(c.ColorProfile()).
+		HasLightBackground(c.HasLightBackground())
 }
 
 func (c *teaContext) ColorProfile() lipgloss.Profile {
-	return c.profile
+	if v, ok := c.Value(ContextKeyColorProfile).(lipgloss.Profile); ok {
+		return v
+	}
+	return lipgloss.TrueColor
 }
 
 func (ctx *teaContext) Value(key interface{}) interface{} {

options.go

@@ -19,7 +19,7 @@ type ProgramOption func(*Program)
 // cancelled it will exit with an error ErrProgramKilled.
 func WithContext(ctx context.Context) ProgramOption {
 	return func(p *Program) {
-		p.ctx = newContext(ctx)
+		p.ctx, p.cancel = newContext(ctx)
 	}
 }
 

tea.go

@@ -136,7 +136,7 @@ type Program struct {
 
 	inputType inputType
 
-	ctx    *teaContext
+	ctx    Context
 	cancel context.CancelFunc
 
 	msgs     chan Msg
@@ -202,10 +202,8 @@ func NewProgram(model Model, opts ...ProgramOption) *Program {
 	// A context can be provided with a ProgramOption, but if none was provided
 	// we'll use the default background context.
 	if p.ctx == nil {
-		p.ctx = newContext(context.Background())
+		p.ctx, p.cancel = newContext(context.Background())
 	}
-	// Initialize context and teardown channel.
-	p.ctx.Context, p.cancel = context.WithCancel(p.ctx)
 
 	// if no output was set, set it to stdout
 	if p.output == nil {
@@ -431,11 +429,11 @@ func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
 func (p *Program) handleContextMessages(msg Msg) {
 	switch msg := msg.(type) {
 	case BackgroundColorMsg:
-		p.ctx.backgroundColor = msg.Color
+		p.ctx.SetValue(ContextKeyBackgroundColor, msg.Color)
 		col, ok := colorful.MakeColor(msg.Color)
 		if ok {
 			_, _, l := col.Hsl()
-			p.ctx.hasLightBg = l > 0.5
+			p.ctx.SetValue(ContextKeyHasLightBackground, l > 0.5)
 		}
 	}
 }
@@ -450,7 +448,7 @@ func (p *Program) Run() (Model, error) {
 	p.finished = make(chan struct{}, 1)
 
 	// Detect color profile.
-	p.ctx.profile = lipgloss.DetectColorProfile(p.output, p.environ)
+	p.ctx.SetValue(ContextKeyColorProfile, lipgloss.DetectColorProfile(p.output, p.environ))
 
 	defer p.cancel()