VirtualTerminal: simplify VTColor.ansi

Inline the `ANSIColor` and add an optional `intensity` attribute,
unwrapping the structure as the payload.

Author: compnerd

Sources/VTDemo/VTDemo.swift

@@ -190,7 +190,7 @@ private struct Menu: Scene {
     buffer.write(string: subtitle,
                  at: VTPosition(row: buffer.size.height / 4 + 1,
                                 column: (buffer.size.width - subtitle.width) / 2),
-                 style: VTStyle(foreground: .ansi(.init(color: .cyan, intensity: .bright)),
+                 style: VTStyle(foreground: .ansi(.cyan, intensity: .bright),
                                 attributes: [.bold]))
 
     // Render the menu options

Sources/VirtualTerminal/Buffer/VTStyle.swift

@@ -48,15 +48,14 @@ extension VTAttributes {
   }
 }
 
-private func pack(_ color: VTColor) -> UInt64 {
-  return switch color {
-  case let .rgb(red, green, blue):
-    // [23-16: red][15-8: green][7-0: blue]
-    (UInt64(red) << 16) | (UInt64(green) << 8) | (UInt64(blue) << 0)
-  case let .ansi(color):
-    // [23-9: reserved][8: intensity][7-0: color]
-    (UInt64(color.intensity == .bright ? 1 : 0) << 8) | (UInt64(color.color.rawValue) & 0xff)
-  }
+private func pack(_ color: ANSIColor, _ intensity: ANSIColorIntensity) -> UInt64 {
+  // [23-9: reserved][8: intensity][7-0: color]
+  return (UInt64(intensity == .bright ? 1 : 0) << 8) | (UInt64(color.rawValue) & 0xff)
+}
+
+private func pack(_ red: UInt8, _ green: UInt8, _ blue: UInt8) -> UInt64 {
+  // [23-16: red][15-8: green][7-0: blue]
+  return (UInt64(red) << 16) | (UInt64(green) << 8) | (UInt64(blue) << 0)
 }
 
 private struct Flags: OptionSet {
@@ -121,22 +120,22 @@ public struct VTStyle: Sendable, Equatable {
   public init(foreground: VTColor? = nil, background: VTColor? = nil, attributes: VTAttributes = []) {
     var representation = (UInt64(attributes.rawValue) << 8)
 
-    if let foreground {
-      switch foreground {
-      case .ansi(_):
-        representation |= (pack(foreground) << 16) | UInt64(Flags.ANSIForeground.rawValue)
-      case .rgb(_, _, _):
-        representation |= (pack(foreground) << 16) | UInt64(Flags.RGBForeground.rawValue)
-      }
+    switch foreground {
+    case .none:
+      representation |= (pack(ANSIColor.default, .normal) << 16) | UInt64(Flags.ANSIForeground.rawValue)
+    case let .some(.ansi(color, intensity)):
+      representation |= (pack(color, intensity) << 16) | UInt64(Flags.ANSIForeground.rawValue)
+    case let .some(.rgb(red, green, blue)):
+      representation |= (pack(red, green, blue) << 16) | UInt64(Flags.RGBForeground.rawValue)
     }
 
-    if let background {
-      switch background {
-      case .ansi(_):
-        representation |= (pack(background) << 40) | UInt64(Flags.ANSIBackground.rawValue)
-      case .rgb(_, _, _):
-        representation |= (pack(background) << 40) | UInt64(Flags.RGBBackground.rawValue)
-      }
+    switch background {
+    case .none:
+      representation |= (pack(ANSIColor.default, .normal) << 40) | UInt64(Flags.ANSIBackground.rawValue)
+    case let .some(.ansi(color, intensity)):
+      representation |= (pack(color, intensity) << 40) | UInt64(Flags.ANSIBackground.rawValue)
+    case let .some(.rgb(red, green, blue)):
+      representation |= (pack(red, green, blue) << 40) | UInt64(Flags.RGBBackground.rawValue)
     }
 
     self.representation = representation
@@ -148,12 +147,12 @@ public struct VTStyle: Sendable, Equatable {
 
     if flags.contains(.ANSIForeground) {
       let bits = representation >> 16
-      guard let color = ANSIColorIdentifier(rawValue: (Int(bits) & 0xff)) else {
+      guard let color = ANSIColor(rawValue: (Int(bits) & 0xff)) else {
         return nil
       }
       let intensity = (bits >> 8) & 1 == 1 ? ANSIColorIntensity.bright
                                            : ANSIColorIntensity.normal
-      return .ansi(ANSIColor(color: color, intensity: intensity))
+      return .ansi(color, intensity: intensity)
     }
 
     if flags.contains(.RGBForeground) {
@@ -174,12 +173,12 @@ public struct VTStyle: Sendable, Equatable {
 
     if flags.contains(.ANSIBackground) {
       let bits = representation >> 40
-      guard let color = ANSIColorIdentifier(rawValue: (Int(bits) & 0xff)) else {
+      guard let color = ANSIColor(rawValue: (Int(bits) & 0xff)) else {
         return nil
       }
       let intensity = (bits >> 8) & 1 == 1 ? ANSIColorIntensity.bright
                                             : ANSIColorIntensity.normal
-      return .ansi(ANSIColor(color: color, intensity: intensity))
+      return .ansi(color, intensity: intensity)
     }
 
     if flags.contains(.RGBBackground) {

Sources/VirtualTerminal/Core/ISO6429.swift

@@ -282,8 +282,8 @@ extension GraphicRendition: CustomStringConvertible {
     case .NotCrossedOut: "29"
     case .Foreground(let color):
       switch color {
-        case .ansi(let color):
-          switch (color.color, color.intensity) {
+        case .ansi(let color, let intensity):
+          switch (color, intensity) {
             case (.black, .normal): "30"
             case (.red, .normal): "31"
             case (.green, .normal): "32"
@@ -311,8 +311,8 @@ extension GraphicRendition: CustomStringConvertible {
       }
     case .Background(let color):
       switch color {
-        case .ansi(let color):
-          switch (color.color, color.intensity) {
+        case .ansi(let color, let intensity):
+          switch (color, intensity) {
             case (.black, .normal): "40"
             case (.red, .normal): "41"
             case (.green, .normal): "42"
@@ -333,6 +333,7 @@ extension GraphicRendition: CustomStringConvertible {
             case (.white, .bright): "107"
             case (.default, .bright): "109"
           }
+
         case .rgb(let red, let green, let blue):
           // 48;2;<r>;<g>;<b>
           "48;2;\(Int(red));\(Int(green));\(Int(blue))"

Sources/VirtualTerminal/Core/VTColor.swift

@@ -7,7 +7,7 @@
 /// has been supported since early terminal systems. The actual appearance
 /// of these colors depends on the terminal's color scheme and user
 /// customization.
-public enum ANSIColorIdentifier: Int, Equatable, Sendable {
+public enum ANSIColor: Int, Equatable, Sendable {
   case black
   case red
   case green
@@ -33,84 +33,6 @@ public enum ANSIColorIntensity: Equatable, Sendable {
   case bright
 }
 
-/// An ANSI color with optional intensity variation.
-///
-/// ANSI colors provide excellent terminal compatibility since they're
-/// supported by virtually all terminal emulators. They automatically
-/// adapt to user color schemes and accessibility settings.
-///
-/// ## Usage Examples
-///
-/// ```swift
-/// // Standard colors
-/// let ANSIRed = ANSIColor(color: .red, intensity: .normal)
-/// let ANSIBrightBlue = ANSIColor(color: .blue, intensity: .bright)
-///
-/// // Using convenience properties
-/// let default = ANSIColor.default
-/// let ANSIBrightGreen = ANSIColor(color: .green, intensity: .bright)
-/// ```
-public struct ANSIColor: Equatable, Hashable, Sendable {
-  @usableFromInline
-  internal let color: ANSIColorIdentifier
-
-  @usableFromInline
-  internal let intensity: ANSIColorIntensity
-
-  /// Creates an ANSI color with the specified identifier and intensity.
-  ///
-  /// - Parameters:
-  ///   - color: The base color identifier.
-  ///   - intensity: The color intensity. Defaults to `.normal`.
-  public init(color: ANSIColorIdentifier, intensity: ANSIColorIntensity = .normal) {
-    self.color = color
-    self.intensity = intensity
-  }
-}
-
-extension ANSIColor {
-  /// The terminal's default color as configured by the user.
-  ///
-  /// This respects terminal color schemes and accessibility settings,
-  /// making it the best choice for primary text that should integrate
-  /// naturally with the user's environment.
-  public static var `default`: ANSIColor {
-    ANSIColor(color: .default, intensity: .normal)
-  }
-
-  public static var black: ANSIColor {
-    ANSIColor(color: .black, intensity: .normal)
-  }
-
-  public static var red: ANSIColor {
-    ANSIColor(color: .red, intensity: .normal)
-  }
-
-  public static var green: ANSIColor {
-    ANSIColor(color: .green, intensity: .normal)
-  }
-
-  public static var yellow: ANSIColor {
-    ANSIColor(color: .yellow, intensity: .normal)
-  }
-
-  public static var blue: ANSIColor {
-    ANSIColor(color: .blue, intensity: .normal)
-  }
-
-  public static var magenta: ANSIColor {
-    ANSIColor(color: .magenta, intensity: .normal)
-  }
-
-  public static var cyan: ANSIColor {
-    ANSIColor(color: .cyan, intensity: .normal)
-  }
-
-  public static var white: ANSIColor {
-    ANSIColor(color: .white, intensity: .normal)
-  }
-}
-
 /// Terminal color representation supporting both ANSI and RGB color spaces.
 ///
 /// `VTColor` provides a unified interface for terminal colors while
@@ -140,7 +62,7 @@ public enum VTColor: Equatable, Hashable, Sendable {
   /// A 24-bit RGB color with precise component control.
   case rgb(red: UInt8, green: UInt8, blue: UInt8)
   /// An ANSI color that adapts to terminal themes and settings.
-  case ansi(ANSIColor)
+  case ansi(_ color: ANSIColor, intensity: ANSIColorIntensity = .normal)
 }
 
 extension VTColor {