Add monochrome palette fallback infrastructure

Author: jongalloway

src/DiagramForge/Models/ColorUtils.cs

@@ -469,6 +469,27 @@ public static string Vibrant(string hex, double amplify = 3.0)
             a);
     }
 
+    /// <summary>
+    /// Derives a vibrant color from <paramref name="hex"/>, but when the input is
+    /// achromatic returns <paramref name="achromaticFallback"/> instead.
+    /// </summary>
+    /// <remarks>
+    /// The fallback keeps the source alpha channel so callers can supply a chromatic
+    /// palette color without losing opacity from the original input.
+    /// </remarks>
+    /// <param name="hex">Hex color string (typically a pastel).</param>
+    /// <param name="achromaticFallback">Chromatic fallback used when <paramref name="hex"/> has no usable hue.</param>
+    /// <param name="amplify">How much to amplify the hue deviation (default 3).</param>
+    public static string Vibrant(string hex, string achromaticFallback, double amplify = 3.0)
+    {
+        if (!IsAchromatic(hex))
+            return Vibrant(hex, amplify);
+
+        var (_, _, _, alpha) = ParseHexWithAlpha(hex);
+        var (fallbackR, fallbackG, fallbackB, _) = ParseHexWithAlpha(achromaticFallback);
+        return ToHex(fallbackR, fallbackG, fallbackB, alpha);
+    }
+
     private static int Clamp(int value) => Math.Max(0, Math.Min(255, value));
 
     /// <summary>

src/DiagramForge/Models/ThemePaletteResolver.cs

@@ -42,9 +42,19 @@ public static class ThemePaletteResolver
     /// A <see cref="IReadOnlyList{T}"/> of hex color strings suitable for node fills.
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="theme"/> is <see langword="null"/>.</exception>
-    public static IReadOnlyList<string> ResolveEffectivePalette(Theme theme)
+    public static IReadOnlyList<string> ResolveEffectivePalette(Theme theme) =>
+        ResolveEffectivePalette(theme, DefaultPaletteSize);
+
+    /// <summary>
+    /// Returns a chromatic palette sized for the caller's repeated-element needs.
+    /// </summary>
+    /// <param name="theme">Source theme.</param>
+    /// <param name="desiredCount">Number of entries to produce for fallback palettes.</param>
+    public static IReadOnlyList<string> ResolveEffectivePalette(Theme theme, int desiredCount)
     {
         ArgumentNullException.ThrowIfNull(theme);
+        if (desiredCount < 1)
+            throw new ArgumentOutOfRangeException(nameof(desiredCount), desiredCount, "desiredCount must be at least 1.");
 
         if (theme.NodePalette is { Count: > 0 } &&
             !ColorUtils.IsPaletteMonochrome(theme.NodePalette, theme.BackgroundColor))
@@ -53,14 +63,14 @@ public static IReadOnlyList<string> ResolveEffectivePalette(Theme theme)
         // Build fallback from gradient stops when they are available and meaningful.
         if (theme.UseBorderGradients && theme.BorderGradientStops is { Count: > 1 })
         {
-            var gradientPalette = BuildPaletteFromGradientStops(theme.BorderGradientStops, DefaultPaletteSize);
+            var gradientPalette = BuildPaletteFromGradientStops(theme.BorderGradientStops, desiredCount);
             if (!ColorUtils.IsPaletteMonochrome(gradientPalette, theme.BackgroundColor))
                 return gradientPalette;
         }
 
         // Fall back to hue-rotation derivation from the theme's semantic colors.
         bool isLightBackground = ColorUtils.IsLight(theme.BackgroundColor);
-        return BuildPaletteFromHueRotation(theme.AccentColor, theme.SecondaryColor, DefaultPaletteSize, isLightBackground);
+        return BuildPaletteFromHueRotation(theme.AccentColor, theme.SecondaryColor, desiredCount, isLightBackground);
     }
 
     // ── Private helpers ───────────────────────────────────────────────────────
@@ -146,6 +156,8 @@ public static string[] BuildRingColors(Theme theme, int ringCount, string center
         if (ringCount < 1)
             throw new ArgumentOutOfRangeException(nameof(ringCount), ringCount, "ringCount must be at least 1.");
 
+        var chromaticPalette = ResolveEffectivePalette(theme, Math.Max(DefaultPaletteSize, ringCount * 2));
+
         var colors = new List<string>(ringCount)
         {
             outerColor,
@@ -156,31 +168,44 @@ public static string[] BuildRingColors(Theme theme, int ringCount, string center
 
         var candidatePool = new List<string>
         {
-            ColorUtils.Vibrant(theme.SecondaryColor, 2.4),
-            ColorUtils.Vibrant(theme.AccentColor, 2.4),
-            ColorUtils.Vibrant(ColorUtils.Blend(theme.SecondaryColor, theme.AccentColor, 0.5), 2.6),
-            ColorUtils.Vibrant(ColorUtils.Blend(theme.AccentColor, theme.PrimaryColor, 0.35), 2.5),
-            ColorUtils.Vibrant(ColorUtils.Blend(theme.PrimaryColor, theme.SecondaryColor, 0.25), 2.5),
+            ColorUtils.Vibrant(theme.SecondaryColor, chromaticPalette[0], 2.4),
+            ColorUtils.Vibrant(theme.AccentColor, chromaticPalette[1 % chromaticPalette.Count], 2.4),
+            ColorUtils.Vibrant(ColorUtils.Blend(theme.SecondaryColor, theme.AccentColor, 0.5), chromaticPalette[2 % chromaticPalette.Count], 2.6),
+            ColorUtils.Vibrant(ColorUtils.Blend(theme.AccentColor, theme.PrimaryColor, 0.35), chromaticPalette[3 % chromaticPalette.Count], 2.5),
+            ColorUtils.Vibrant(ColorUtils.Blend(theme.PrimaryColor, theme.SecondaryColor, 0.25), chromaticPalette[4 % chromaticPalette.Count], 2.5),
             ColorUtils.RotateHue(theme.SecondaryColor, 34, isLightBackground),
             ColorUtils.RotateHue(theme.AccentColor, -34, isLightBackground),
             ColorUtils.RotateHue(theme.PrimaryColor, 52, isLightBackground),
         };
 
         if (theme.NodePalette is { Count: > 0 })
         {
-            foreach (var paletteColor in theme.NodePalette)
+            for (int i = 0; i < theme.NodePalette.Count; i++)
             {
-                candidatePool.Add(ColorUtils.Vibrant(paletteColor, 2.6));
-                candidatePool.Add(ColorUtils.RotateHue(paletteColor, 28, isLightBackground));
+                string paletteColor = theme.NodePalette[i];
+                string fallbackColor = chromaticPalette[i % chromaticPalette.Count];
+                candidatePool.Add(ColorUtils.Vibrant(paletteColor, fallbackColor, 2.6));
+                candidatePool.Add(ColorUtils.RotateHue(fallbackColor, 28, isLightBackground));
             }
         }
 
+        candidatePool.AddRange(chromaticPalette);
+
         var distinctCandidates = candidatePool
             .Select(color => ColorUtils.Blend(color, theme.BackgroundColor, isLightBackground ? 0.06 : 0.10))
             .Distinct(StringComparer.OrdinalIgnoreCase)
             .Where(color => ColorUtils.GetHueDistance(color, outerColor) >= 18)
             .ToList();
 
+        if (ColorUtils.IsPaletteMonochrome(distinctCandidates, theme.BackgroundColor))
+        {
+            distinctCandidates = chromaticPalette
+                .Select(color => ColorUtils.Blend(color, theme.BackgroundColor, isLightBackground ? 0.06 : 0.10))
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Where(color => ColorUtils.GetHueDistance(color, outerColor) >= 18)
+                .ToList();
+        }
+
         while (colors.Count < ringCount)
         {
             string? nextColor = distinctCandidates

tests/DiagramForge.Tests/Models/ColorUtilsTests.cs

@@ -905,5 +905,17 @@ public void Vibrant_AchromaticInput_PreservesAlphaChannel()
         var (_, _, _, a) = ColorUtils.ParseHexWithAlpha(result);
         Assert.Equal(0xCC, a);
     }
+
+    [Fact]
+    public void Vibrant_AchromaticInput_WithChromaticFallback_UsesFallbackHueAndPreservesAlpha()
+    {
+        string result = ColorUtils.Vibrant("#FFFFFF80", "#2563EB");
+
+        Assert.False(ColorUtils.IsAchromatic(result));
+
+        var (r, g, b, a) = ColorUtils.ParseHexWithAlpha(result);
+        Assert.Equal((37, 99, 235), (r, g, b));
+        Assert.Equal(0x80, a);
+    }
 }
 

tests/DiagramForge.Tests/Models/ThemePaletteResolverTests.cs

@@ -104,6 +104,25 @@ public void BuildRingColors_WithNodePalette_InfluencesSelection()
         Assert.True(anyDiffers, "NodePalette entries should influence at least one ring color selection.");
     }
 
+    [Fact]
+    public void BuildRingColors_PrismTheme_UsesChromaticInnerRingFallback()
+    {
+        string[] result = ThemePaletteResolver.BuildRingColors(
+            Theme.Prism,
+            ringCount: 5,
+            centerColor: "#FFFFFF",
+            outerColor: "#D6DEE8",
+            isLightBackground: true);
+
+        Assert.Equal(5, result.Length);
+        Assert.Equal("#D6DEE8", result[0], ignoreCase: true);
+
+        string[] innerRings = result.Skip(1).ToArray();
+        Assert.All(innerRings, color => Assert.False(ColorUtils.IsAchromatic(color)));
+        Assert.False(ColorUtils.IsPaletteMonochrome(innerRings, Theme.Prism.BackgroundColor),
+            "Prism inner ring colors should come from a chromatic fallback palette rather than stay monochrome.");
+    }
+
     // ── BuildRingColors — fallback path ───────────────────────────────────────
 
     [Fact]
@@ -210,6 +229,17 @@ public void ResolveEffectivePalette_PrismTheme_ReturnsChromaticFallback()
             "Prism fallback palette derived from gradient stops should not be monochrome.");
     }
 
+    [Fact]
+    public void ResolveEffectivePalette_PrismTheme_WithRequestedCount_ReturnsChromaticFallbackOfRequestedSize()
+    {
+        var result = ThemePaletteResolver.ResolveEffectivePalette(Theme.Prism, desiredCount: 12);
+
+        Assert.Equal(12, result.Count);
+        Assert.Equal(Theme.Prism.BorderGradientStops![0], result[0], ignoreCase: true);
+        Assert.Equal(Theme.Prism.BorderGradientStops[^1], result[^1], ignoreCase: true);
+        Assert.False(ColorUtils.IsPaletteMonochrome(result, Theme.Prism.BackgroundColor));
+    }
+
     [Fact]
     public void ResolveEffectivePalette_MonochromeNoGradientStops_UsesHueRotationFallback()
     {