unmagic-color 0.2.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 276b2cc6192a6fea7e69f4893c9989434e8101c3e9c6a88b56996eeeeb910262
-  data.tar.gz: cd421ccce7640490b140a74a62640ee9dbbb6060f815d770b14ac12e4b1ff991
+  metadata.gz: 8e8aee8c90b0b846c5352c1a8c2f9638fdbceaa830a8b240805c093326bd0a5e
+  data.tar.gz: febb8693169a657fd975d9d60e69232a291aa1f1a8a3cd05372f279a008cbe9d
 SHA512:
-  metadata.gz: 2da573372028a3d08793d01bcd9245a24fc88934085b081712934e4606a2d60ff03d8c8f6f94b06abb2fb6817e1b5b0acdf8ac2fd332e1d9f9b2923a90221d5c
-  data.tar.gz: 8a17575b7f89b7f9c29d613208972242bd851e42b25659a7533a4c6ed156ce14f9f9396148aa6e171ad5a8e0159395d8e9f9e28b881fa000bbdeb6492cc40388
+  metadata.gz: d6df173651d743f7e4696d22334afaedcac56160e4ec579e2a00c2d06b80802724fd2f3e6da36cd05970994aa14e4ed0466fe33bf1f188b98f291385ed351a0a
+  data.tar.gz: 46b517537f8393d29c26567daebbfd83913d8d7cd56766f7caa7d35b048161e9c8977865bd9d36ca75669d8296179290fcf2d38c4e1c58780740707158e3ee68

data/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3] - 2026-05-17
+
+### Added
+
+#### Perceptual Tonal Scales
+- `scale(steps:, lightness:, chroma:, hue_shift:, anchor:, gamut:)` - generates perceptually-uniform tonal palettes in OKLCH, controlling lightness, chroma, and hue independently
+- An 11-step scale anchored in the middle produces a Tailwind-style 50–950 palette (`scale` itself knows nothing about Tailwind)
+- Tapered default chroma curve that rises into the mid-tones and eases off near white and black, avoiding muddy lights and neon darks
+- `anchor:` pins the source color to an exact step and builds the rest of the scale around it
+- `lightness:`, `chroma:`, and `hue_shift:` accept ranges, arrays, or procs for full control over each curve
+- `gamut:` gamut-maps results into sRGB by default, or returns raw wide-gamut OKLCH with `:none`
+
+#### OKLCH Gamut Mapping
+- `OKLCH#in_gamut?` - reports whether a color is displayable within the sRGB gamut
+- `OKLCH#clamp_to_gamut` - pulls an out-of-gamut color into sRGB by reducing chroma while holding lightness and hue fixed (perceptually correct, unlike per-channel RGB clipping)
+- `OKLCH#to_oklab` - converts to the cartesian OKLab color space
+
+### Fixed
+- Rainbow gradient rendering in the WebAssembly demo
+
+## [0.2.2] - 2026-01-05
+
+### Added
+- `Gradient::Bitmap#to_ansi` method to render gradients as colored blocks in terminal
+
 ## [0.2.1] - 2026-01-05
 
 ### Added
@@ -81,6 +106,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - HSL color progressions for palette generation
 - Multiple hash functions for string-to-color derivation
 
+[0.2.2]: https://github.com/unreasonable-magic/unmagic-color/releases/tag/v0.2.2
 [0.2.1]: https://github.com/unreasonable-magic/unmagic-color/releases/tag/v0.2.1
 [0.2.0]: https://github.com/unreasonable-magic/unmagic-color/releases/tag/v0.2.0
 [0.1.0]: https://github.com/unreasonable-magic/unmagic-color/releases/tag/v0.1.0

data/README.md

@@ -4,6 +4,8 @@
 
 A comprehensive Ruby color manipulation library with support for RGB, HSL, and OKLCH color spaces. Parse, convert, and manipulate colors with an intuitive API.
 
+We have a fancy-pants WASM based demo here: https://unreasonable-magic.github.io/unmagic-color/
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/unmagic/color/console/help.rb

@@ -17,38 +17,23 @@ module Unmagic
           link = highlighter.link("https://github.com/unreasonable-magic/unmagic-color")
 
           code = highlighter.highlight(<<~RUBY)
-            # Parse colors
+            # Parse a color (hex, rgb, hsl, oklch, ansi, css named, x11)
             parse("#ff5733")
-            rgb(255, 87, 51)
+            parse("goldenrod")
+
+            # Manually create colors
+            rgb(255, 87, 51, alpha: percentage(50))
             hsl(9, 100, 60)
             oklch(0.65, 0.22, 30)
-            parse("rebeccapurple")
-
-            # Manipulate colors
-            color = parse("#ff5733")
-            color.lighten(0.1)
-            color.darken(0.1)
-            color.saturate(0.1)
-            color.desaturate(0.1)
-            color.rotate(30)
 
-            # Convert between formats
-            color.to_rgb
-            color.to_hsl
-            color.to_oklch
-            color.to_hex
-            color.to_css_oklch
+            # Show a color card
+            show("#ff5733")
 
-            # Create gradients
-            gradient(:linear, ["#FF0000", "#0000FF"]).rasterize(width: 10).pixels[0].map(&:to_hex)
+            # Make a rainbow
+            puts gradient(:linear, %w[red orange yellow green blue purple], direction: "to right").rasterize(width: 60).to_ansi
 
-            # Helpers
-            rgb(255, 87, 51)
-            hsl(9, 100, 60)
-            oklch(0.65, 0.22, 30)
-            parse("#ff5733")
-            gradient(:linear, ["#FF0000", "#0000FF"])
-            percentage(50)
+            # Generate Tailwind color scales
+            puts gradient(:linear, parse("#3b82f6").scale(steps: 11, anchor: 5), direction: "to right").rasterize(width: 60).to_ansi
           RUBY
 
           "#{link}\n\n#{code}"

data/lib/unmagic/color/gradient/bitmap.rb

@@ -85,6 +85,27 @@ module Unmagic
         def to_a
           @pixels.flatten
         end
+
+        # Convert to ANSI escape codes for terminal display.
+        #
+        # Renders each pixel as a colored character using 24-bit true color
+        # ANSI codes. Each row is joined and rows are separated by newlines.
+        #
+        # @param fill [String] Character to use for each pixel (default: "█")
+        # @return [String] ANSI-colored string representation
+        #
+        # @example Render a rainbow gradient
+        #   gradient = Gradient.linear(%w[red yellow green blue])
+        #   bitmap = gradient.rasterize(width: 40)
+        #   puts bitmap.to_ansi
+        #
+        # @example Use custom fill character
+        #   puts bitmap.to_ansi(fill: "▀")
+        def to_ansi(fill: "█")
+          @pixels.map do |row|
+            row.map { |color| "\e[#{color.to_ansi}m#{fill}\e[0m" }.join
+          end.join("\n")
+        end
       end
     end
   end

data/lib/unmagic/color/harmony.rb

@@ -5,8 +5,9 @@ module Unmagic
     # Color harmony and variations module.
     #
     # Provides methods for generating harmonious color palettes based on
-    # color theory principles. All calculations are performed in HSL color space
-    # for accurate hue-based relationships.
+    # color theory principles. Harmony and the {#shades}/{#tints}/{#tones}
+    # variations are computed in HSL color space for accurate hue-based
+    # relationships; {#scale} is computed in OKLCH for perceptual uniformity.
     #
     # Included in the base Color class, making these methods available to
     # RGB, HSL, and OKLCH color spaces via inheritance.
@@ -40,6 +41,25 @@ module Unmagic
     #   blue.shades(steps: 3)      # => [darker1, darker2, darker3]
     #   blue.tints(steps: 3)       # => [lighter1, lighter2, lighter3]
     module Harmony
+      # Default lightness curve for {#scale}: 11 control points describing the
+      # *shape* of the light→dark sweep (1.0 = lightest, 0.0 = darkest), sampled
+      # with linear interpolation. Derived from the average of several
+      # hand-tuned production color ramps.
+      SCALE_LIGHTNESS_SHAPE = [
+        1.0, 0.948, 0.876, 0.769, 0.622, 0.514, 0.416, 0.323, 0.234, 0.168, 0.0,
+      ].freeze
+
+      # Default chroma curve for {#scale}: 11 control points (peak normalized
+      # to 1.0). Chroma rises into the mid-tones and tapers toward both ends —
+      # a constant chroma reads as muddy near white and neon near black, and
+      # the sRGB gamut itself narrows at the extremes.
+      SCALE_CHROMA_CURVE = [
+        0.055, 0.131, 0.247, 0.447, 0.727, 0.920, 1.0, 0.931, 0.767, 0.586, 0.374,
+      ].freeze
+
+      # Default lightness endpoints `[lightest, darkest]` for {#scale}.
+      SCALE_LIGHTNESS_DEFAULT = [0.971, 0.270].freeze
+
       # Returns the complementary color (180° opposite on the color wheel).
       #
       # Complementary colors create high contrast and visual tension.
@@ -260,8 +280,174 @@ module Unmagic
         end
       end
 
+      # Generate a perceptually-uniform tonal scale from this color.
+      #
+      # Produces an ordered sequence of colors from light to dark, computed in
+      # the OKLCH color space so each step sits an even perceptual distance
+      # from the last. Unlike {#shades}/{#tints} (which blend toward black or
+      # white in HSL), `scale` controls lightness, chroma, and hue
+      # independently and gamut-maps every result.
+      #
+      # The chroma curve is the important part: chroma rises into the
+      # mid-tones and tapers toward both ends, because a constant chroma reads
+      # as muddy near white and as neon near black, and because the sRGB gamut
+      # itself narrows at the extremes.
+      #
+      # This is a general-purpose primitive. An 11-step scale anchored in the
+      # middle happens to produce a Tailwind-style 50–950 palette, but the
+      # method itself knows nothing about Tailwind.
+      #
+      # @param steps [Integer] Number of colors to generate (must be at least 2)
+      # @param lightness [Range, Array<Numeric>, Proc, nil] OKLCH lightness
+      #   control. A `Range` gives the light/dark endpoints; an `Array` gives
+      #   an explicit value per step; a `Proc` is called with `(t, index)`;
+      #   `nil` uses the default curve.
+      # @param chroma [Symbol, Array<Numeric>, Proc] OKLCH chroma control.
+      #   `:peak` (default) applies the tapered curve scaled to this color's
+      #   chroma; `:flat` holds chroma constant; an `Array` or `Proc` supplies
+      #   values directly.
+      # @param hue_shift [Range, Numeric, Proc, nil] Hue drift in degrees
+      #   across the scale. `nil` (default) keeps the hue constant.
+      # @param anchor [Integer, nil] Index at which this color is placed
+      #   exactly — its lightness, chroma, and hue are preserved at that step
+      #   and the rest of the scale is built around it.
+      # @param gamut [Symbol] `:srgb` (default) gamut-maps every result into
+      #   sRGB so {RGB#to_hex} is trustworthy; `:none` returns the raw OKLCH
+      #   colors, which may be wider than sRGB.
+      # @return [Array<OKLCH>] `steps` colors in OKLCH, ordered light to dark
+      # @raise [ArgumentError] If steps < 2, anchor is out of range, or gamut
+      #   is not :srgb or :none
+      #
+      # @example An 11-step palette anchored on the base color
+      #   base = Unmagic::Color.parse("oklch(0.62 0.21 260)")
+      #   palette = base.scale(steps: 11, anchor: 5)
+      #
+      # @example Label an 11-step scale as Tailwind stops
+      #   stops = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950]
+      #   tailwind = stops.zip(base.scale(steps: 11, anchor: 5)).to_h
+      def scale(steps: 11, lightness: nil, chroma: :peak, hue_shift: nil, anchor: nil, gamut: :srgb)
+        raise ArgumentError, "steps must be at least 2" if steps < 2
+        if anchor && !(0...steps).cover?(anchor)
+          raise ArgumentError, "anchor must be between 0 and #{steps - 1}"
+        end
+        unless [:srgb, :none].include?(gamut)
+          raise ArgumentError, "gamut must be :srgb or :none"
+        end
+
+        base = to_oklch
+        positions = Array.new(steps) { |i| i.fdiv(steps - 1) }
+
+        lightnesses = scale_lightness(positions, lightness, anchor, base.lightness)
+        chromas = scale_chroma(positions, chroma, anchor, base.chroma.value)
+        hues = scale_hue(positions, hue_shift, base.hue.value)
+
+        Array.new(steps) do |i|
+          color = OKLCH.new(
+            lightness: lightnesses[i].clamp(0.0, 1.0),
+            chroma: [chromas[i], 0.0].max,
+            hue: hues[i],
+            alpha: base.alpha.value,
+          )
+          gamut == :none ? color : color.clamp_to_gamut
+        end
+      end
+
       private
 
+      # Compute the OKLCH lightness for each step of a {#scale}.
+      #
+      # @return [Array<Float>] One lightness ratio (0.0-1.0) per step
+      def scale_lightness(positions, lightness, anchor, base_lightness)
+        case lightness
+        when Array
+          positions.each_index.map { |i| lightness[i] || lightness.last }
+        when Proc
+          positions.each_index.map { |i| lightness.call(positions[i], i) }
+        else
+          light, dark = if lightness.is_a?(Range)
+            [lightness.begin.to_f, lightness.end.to_f]
+          else
+            SCALE_LIGHTNESS_DEFAULT
+          end
+          shape = positions.map { |t| interpolate_curve(SCALE_LIGHTNESS_SHAPE, t) }
+          return shape.map { |s| dark + (light - dark) * s } unless anchor
+
+          warp_lightness_to_anchor(shape, shape[anchor], base_lightness, light, dark)
+        end
+      end
+
+      # Warp the lightness shape so it passes exactly through the base color's
+      # lightness at the anchor, keeping the curve monotonic and pinned to the
+      # light/dark endpoints. The light and dark halves are scaled separately.
+      #
+      # @return [Array<Float>] One lightness ratio per step
+      def warp_lightness_to_anchor(shape, anchor_shape, base_lightness, light, dark)
+        shape.map do |s|
+          if s >= anchor_shape
+            next base_lightness if anchor_shape >= 1.0
+
+            base_lightness + (light - base_lightness) * (s - anchor_shape) / (1.0 - anchor_shape)
+          else
+            next base_lightness unless anchor_shape.positive?
+
+            dark + (base_lightness - dark) * s / anchor_shape
+          end
+        end
+      end
+
+      # Compute the OKLCH chroma for each step of a {#scale}.
+      #
+      # @return [Array<Float>] One chroma value per step
+      def scale_chroma(positions, chroma, anchor, base_chroma)
+        case chroma
+        when :flat
+          positions.map { base_chroma }
+        when Array
+          positions.each_index.map { |i| chroma[i] || chroma.last }
+        when Proc
+          positions.each_index.map { |i| chroma.call(positions[i], i) }
+        when :peak, nil
+          curve = positions.map { |t| interpolate_curve(SCALE_CHROMA_CURVE, t) }
+          reference = anchor ? curve[anchor] : curve.max
+          factor = reference.zero? ? 0.0 : base_chroma / reference
+          curve.map { |c| c * factor }
+        else
+          raise ArgumentError, "chroma must be :peak, :flat, an Array, or a Proc"
+        end
+      end
+
+      # Compute the OKLCH hue for each step of a {#scale}.
+      #
+      # @return [Array<Float>] One hue value (degrees) per step
+      def scale_hue(positions, hue_shift, base_hue)
+        case hue_shift
+        when nil
+          positions.map { base_hue }
+        when Range
+          from = hue_shift.begin.to_f
+          to = hue_shift.end.to_f
+          positions.map { |t| base_hue + from + (to - from) * t }
+        when Numeric
+          positions.map { |t| base_hue + (hue_shift * t) }
+        when Proc
+          positions.each_index.map { |i| base_hue + hue_shift.call(positions[i], i) }
+        else
+          raise ArgumentError, "hue_shift must be nil, a Range, Numeric, or a Proc"
+        end
+      end
+
+      # Sample an evenly-spaced control-point array at position `t` (0.0-1.0),
+      # linearly interpolating between the two nearest points.
+      #
+      # @return [Float] The interpolated value
+      def interpolate_curve(control, t)
+        t = t.clamp(0.0, 1.0)
+        x = t * (control.length - 1)
+        low = x.floor
+        high = [low + 1, control.length - 1].min
+        control[low] + (control[high] - control[low]) * (x - low)
+      end
+
       # Rotate the hue by the specified degrees and return a new color.
       #
       # @param degrees [Numeric] Degrees to rotate (positive = clockwise)

data/lib/unmagic/color/oklch.rb

@@ -275,31 +275,82 @@ module Unmagic
         to_rgb.to_hsl
       end
 
+      # Convert to the OKLab color space as `[lightness, a, b]`.
+      #
+      # OKLab is the cartesian form of OKLCH: `a` is the green–red axis and
+      # `b` is the blue–yellow axis. The Euclidean distance between two OKLab
+      # triples is a perceptual color difference (ΔE).
+      #
+      # @return [Array<Float>] The `[L, a, b]` OKLab coordinates
+      #
+      # @example
+      #   color = OKLCH.new(lightness: 0.65, chroma: 0.15, hue: 240)
+      #   l, a, b = color.to_oklab
+      def to_oklab
+        h_rad = @hue.value * Math::PI / 180.0
+        c = @chroma.value
+        [@lightness.to_ratio, c * Math.cos(h_rad), c * Math.sin(h_rad)]
+      end
+
       # Convert to RGB color space.
       #
-      # @return [RGB] The color in RGB color space (approximation)
-      # @note This is currently a simplified approximation. A proper OKLCH to sRGB
-      #   conversion requires more complex color science calculations.
+      # Uses the full OKLab color-science pipeline: OKLCH → OKLab → linear
+      # sRGB → gamma-encoded sRGB. Colors outside the sRGB gamut are clipped
+      # per channel; call {#clamp_to_gamut} first for a perceptual fit.
+      #
+      # @return [RGB] The color in RGB color space
       def to_rgb
-        # For now, convert via approximation - would need proper OKLCH->sRGB conversion
-        # This is a simplified placeholder that approximates RGB from OKLCH
         require_relative "rgb"
 
-        # Simple approximation: use lightness and chroma to estimate RGB
-        base = (@lightness.to_ratio * 255).round
-        saturation = (@chroma * 255).value
+        r, g, b = to_linear_srgb.map { |channel| linear_to_srgb(channel) }
+        Unmagic::Color::RGB.new(
+          red: (r * 255).round.clamp(0, 255),
+          green: (g * 255).round.clamp(0, 255),
+          blue: (b * 255).round.clamp(0, 255),
+          alpha: @alpha,
+        )
+      end
 
-        # Convert hue to RGB ratios (very simplified)
-        h_rad = (@hue * Math::PI / 180).value
-        r_offset = (Math.cos(h_rad) * saturation).round
-        g_offset = (Math.cos(h_rad + 2 * Math::PI / 3) * saturation).round
-        b_offset = (Math.cos(h_rad + 4 * Math::PI / 3) * saturation).round
+      # Whether this color can be displayed in the sRGB gamut.
+      #
+      # OKLCH can describe colors no sRGB monitor can show — typically
+      # high-chroma colors near very light or very dark lightness, where the
+      # sRGB gamut narrows. This returns false for those.
+      #
+      # @param epsilon [Float] Tolerance for channels sitting just past 0 or 1
+      # @return [Boolean] true if every linear sRGB channel falls within [0, 1]
+      def in_gamut?(epsilon = 1e-4)
+        to_linear_srgb.all? { |channel| channel >= -epsilon && channel <= 1.0 + epsilon }
+      end
 
-        r = (base + r_offset).clamp(0, 255)
-        g = (base + g_offset).clamp(0, 255)
-        b = (base + b_offset).clamp(0, 255)
+      # Pull this color into the sRGB gamut by reducing chroma.
+      #
+      # Holds lightness and hue fixed and binary-searches chroma downward
+      # until the color is displayable. An already-displayable color is
+      # returned unchanged. This is the perceptually correct way to map an
+      # out-of-gamut OKLCH color — clipping RGB channels instead shifts hue.
+      #
+      # @return [OKLCH] An in-gamut color with the same lightness and hue
+      #
+      # @example
+      #   vivid = OKLCH.new(lightness: 0.95, chroma: 0.3, hue: 140)
+      #   vivid.clamp_to_gamut # => a displayable, lower-chroma green
+      def clamp_to_gamut
+        return self if in_gamut?
+
+        lo = 0.0
+        hi = @chroma.value
+        20.times do
+          mid = (lo + hi) / 2.0
+          candidate = self.class.new(lightness: @lightness.to_ratio, chroma: mid, hue: @hue.value, alpha: @alpha.value)
+          if candidate.in_gamut?
+            lo = mid
+          else
+            hi = mid
+          end
+        end
 
-        Unmagic::Color::RGB.new(red: r, green: g, blue: b, alpha: @alpha)
+        self.class.new(lightness: @lightness.to_ratio, chroma: lo, hue: @hue.value, alpha: @alpha.value)
       end
 
       # Convert to hex string.
@@ -540,6 +591,37 @@ module Unmagic
       def clamp01(x)
         x.clamp(0.0, 1.0)
       end
+
+      # OKLCH → OKLab → linear sRGB. Channels may fall outside [0, 1] when the
+      # color is out of gamut; callers clip or gamut-map as needed.
+      #
+      # @return [Array<Float>] Linear (non-gamma) sRGB channels
+      def to_linear_srgb
+        l, a, b = to_oklab
+
+        l_ = ((l + (0.3963377774 * a) + (0.2158037573 * b))**3)
+        m_ = ((l - (0.1055613458 * a) - (0.0638541728 * b))**3)
+        s_ = ((l - (0.0894841775 * a) - (1.2914855480 * b))**3)
+
+        [
+          (4.0767416621 * l_) - (3.3077115913 * m_) + (0.2309699292 * s_),
+          (-1.2684380046 * l_) + (2.6097574011 * m_) - (0.3413193965 * s_),
+          (-0.0041960863 * l_) - (0.7034186147 * m_) + (1.7076147010 * s_),
+        ]
+      end
+
+      # Gamma-encode a single linear sRGB channel, clipping to [0, 1].
+      #
+      # @param channel [Float] A linear sRGB channel value
+      # @return [Float] The gamma-encoded sRGB channel (0.0-1.0)
+      def linear_to_srgb(channel)
+        channel = channel.clamp(0.0, 1.0)
+        if channel <= 0.0031308
+          12.92 * channel
+        else
+          (1.055 * (channel**(1 / 2.4))) - 0.055
+        end
+      end
     end
   end
 end

data/lib/unmagic/color/rgb.rb

@@ -379,21 +379,31 @@ module Unmagic
 
       # Convert to OKLCH color space.
       #
-      # Converts this RGB color to OKLCH (Lightness, Chroma, Hue).
+      # Converts this RGB color to OKLCH (Lightness, Chroma, Hue) using the
+      # full OKLab color-science pipeline: gamma-decoded sRGB → linear sRGB →
+      # OKLab → OKLCH.
       #
       # @return [OKLCH] The color in OKLCH color space
-      # @note This is currently a simplified approximation.
       def to_oklch
-        # For now, simple approximation based on RGB -> HSL -> OKLCH
-        # This is a simplified placeholder
         require_relative "oklch"
-        # Convert lightness roughly from RGB luminance
-        l = luminance
-        # Approximate chroma from saturation and lightness
-        hsl = to_hsl
-        c = hsl.saturation.to_ratio * 0.2 * (1 - (l - 0.5).abs * 2)
-        h = hsl.hue
-        Unmagic::Color::OKLCH.new(lightness: l, chroma: c, hue: h, alpha: @alpha)
+
+        r = srgb_to_linear(@red.value / 255.0)
+        g = srgb_to_linear(@green.value / 255.0)
+        b = srgb_to_linear(@blue.value / 255.0)
+
+        l = Math.cbrt((0.4122214708 * r) + (0.5363325363 * g) + (0.0514459929 * b))
+        m = Math.cbrt((0.2119034982 * r) + (0.6806995451 * g) + (0.1073969566 * b))
+        s = Math.cbrt((0.0883024619 * r) + (0.2817188376 * g) + (0.6299787005 * b))
+
+        ok_l = (0.2104542553 * l) + (0.7936177850 * m) - (0.0040720468 * s)
+        ok_a = (1.9779984951 * l) - (2.4285922050 * m) + (0.4505937099 * s)
+        ok_b = (0.0259040371 * l) + (0.7827717662 * m) - (0.8086757660 * s)
+
+        chroma = Math.sqrt((ok_a * ok_a) + (ok_b * ok_b))
+        hue = Math.atan2(ok_b, ok_a) * 180.0 / Math::PI
+        hue += 360.0 if hue.negative?
+
+        Unmagic::Color::OKLCH.new(lightness: ok_l, chroma: chroma, hue: hue, alpha: @alpha)
       end
 
       # Calculate the relative luminance.
@@ -549,6 +559,18 @@ module Unmagic
 
       private
 
+      # Gamma-decode a single sRGB channel to linear light.
+      #
+      # @param channel [Float] An sRGB channel value (0.0-1.0)
+      # @return [Float] The linear sRGB channel value
+      def srgb_to_linear(channel)
+        if channel <= 0.04045
+          channel / 12.92
+        else
+          ((channel + 0.055) / 1.055)**2.4
+        end
+      end
+
       # Convert to ANSI true color format (24-bit RGB).
       #
       # @param layer [Symbol] Foreground or background layer

data/lib/unmagic/color/version.rb

@@ -3,6 +3,6 @@
 module Unmagic
   class Color
     # Current version of the Unmagic::Color gem
-    VERSION = "0.2.1"
+    VERSION = "0.3"
   end
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unmagic-color
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: '0.3'
 platform: ruby
 authors:
 - Keith Pitt
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-05-17 00:00:00.000000000 Z
 dependencies: []
 description: Parse, convert, and manipulate colors with support for RGB, Hex, HSL
   formats, contrast calculations, and color blending
@@ -55,6 +56,7 @@ metadata:
   homepage_uri: https://github.com/unreasonable-magic/unmagic-color
   source_code_uri: https://github.com/unreasonable-magic/unmagic-color
   changelog_uri: https://github.com/unreasonable-magic/unmagic-color/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,7 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Comprehensive color manipulation library
 test_files: []