@trishchuk/coolors-mcp 1.0.0

package/src/color/conversions.ts

@@ -0,0 +1,393 @@
+/**
+ * Color space conversion functions
+ */
+
+import type { HEX, HSL, HSV, LAB, RGB, XYZ } from "./types.js";
+
+import { ColorConstants } from "./types.js";
+
+/**
+ * Convert ARGB format to RGB
+ */
+export function argbToRgb(argb: number): RGB {
+  const r = (argb >> 16) & 0xff;
+  const g = (argb >> 8) & 0xff;
+  const b = argb & 0xff;
+  return { b, g, r };
+}
+
+/**
+ * Convert hexadecimal to RGB color
+ */
+export function hexToRgb(hex: HEX): RGB {
+  // Remove # if present
+  const cleanHex = hex.replace("#", "");
+
+  // Handle 3-digit hex
+  const fullHex =
+    cleanHex.length === 3
+      ? cleanHex
+          .split("")
+          .map((c) => c + c)
+          .join("")
+      : cleanHex;
+
+  const num = parseInt(fullHex, 16);
+
+  return {
+    b: num & 255,
+    g: (num >> 8) & 255,
+    r: (num >> 16) & 255,
+  };
+}
+
+/**
+ * Convert HSL to RGB color space
+ */
+export function hslToRgb(hsl: HSL): RGB {
+  const h = hsl.h / 360;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+
+  let b: number, g: number, r: number;
+
+  if (s === 0) {
+    r = g = b = l; // achromatic
+  } else {
+    const hue2rgb = (p: number, q: number, t: number): number => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p + (q - p) * 6 * t;
+      if (t < 1 / 2) return q;
+      if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+      return p;
+    };
+
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+
+  return {
+    b: Math.round(b * 255),
+    g: Math.round(g * 255),
+    r: Math.round(r * 255),
+  };
+}
+
+/**
+ * Convert HSV to RGB color space
+ */
+export function hsvToRgb(hsv: HSV): RGB {
+  const h = hsv.h / 360;
+  const s = hsv.s / 100;
+  const v = hsv.v / 100;
+
+  const i = Math.floor(h * 6);
+  const f = h * 6 - i;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+
+  let b: number, g: number, r: number;
+
+  switch (i % 6) {
+    case 0:
+      r = v;
+      g = t;
+      b = p;
+      break;
+    case 1:
+      r = q;
+      g = v;
+      b = p;
+      break;
+    case 2:
+      r = p;
+      g = v;
+      b = t;
+      break;
+    case 3:
+      r = p;
+      g = q;
+      b = v;
+      break;
+    case 4:
+      r = t;
+      g = p;
+      b = v;
+      break;
+    case 5:
+      r = v;
+      g = p;
+      b = q;
+      break;
+    default:
+      r = 0;
+      g = 0;
+      b = 0;
+  }
+
+  return {
+    b: Math.round(b * 255),
+    g: Math.round(g * 255),
+    r: Math.round(r * 255),
+  };
+}
+
+/**
+ * Convert LAB to RGB color space
+ */
+export function labToRgb(lab: LAB): RGB {
+  return xyzToRgb(labToXyz(lab));
+}
+
+/**
+ * Convert LAB to XYZ color space
+ */
+export function labToXyz(lab: LAB): XYZ {
+  const { D65, EPSILON, KAPPA } = ColorConstants;
+
+  const fy = (lab.l + 16) / 116;
+  const fx = lab.a / 500 + fy;
+  const fz = fy - lab.b / 200;
+
+  const x3 = Math.pow(fx, 3);
+  const y3 = Math.pow(fy, 3);
+  const z3 = Math.pow(fz, 3);
+
+  const x = x3 > EPSILON ? x3 : (116 * fx - 16) / KAPPA;
+  const y = lab.l > KAPPA * EPSILON ? y3 : lab.l / KAPPA;
+  const z = z3 > EPSILON ? z3 : (116 * fz - 16) / KAPPA;
+
+  return {
+    x: x * D65.X,
+    y: y * D65.Y,
+    z: z * D65.Z,
+  };
+}
+
+/**
+ * Parse color string to RGB
+ * Supports: hex (#fff, #ffffff), rgb(r,g,b), hsl(h,s,l)
+ */
+export function parseColor(color: string): null | RGB {
+  const trimmed = color.trim().toLowerCase();
+
+  // Hex color
+  if (trimmed.startsWith("#")) {
+    try {
+      return hexToRgb(trimmed);
+    } catch {
+      return null;
+    }
+  }
+
+  // RGB color
+  const rgbMatch = trimmed.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (rgbMatch) {
+    return {
+      b: parseInt(rgbMatch[3], 10),
+      g: parseInt(rgbMatch[2], 10),
+      r: parseInt(rgbMatch[1], 10),
+    };
+  }
+
+  // HSL color
+  const hslMatch = trimmed.match(/^hsla?\((\d+),\s*(\d+)%,\s*(\d+)%/);
+  if (hslMatch) {
+    return hslToRgb({
+      h: parseInt(hslMatch[1], 10),
+      l: parseInt(hslMatch[3], 10),
+      s: parseInt(hslMatch[2], 10),
+    });
+  }
+
+  return null;
+}
+
+/**
+ * Convert RGB to ARGB format (32-bit integer)
+ */
+export function rgbToArgb(rgb: RGB): number {
+  const r = Math.round(Math.max(0, Math.min(255, rgb.r)));
+  const g = Math.round(Math.max(0, Math.min(255, rgb.g)));
+  const b = Math.round(Math.max(0, Math.min(255, rgb.b)));
+  // Use >>> 0 to convert to unsigned 32-bit integer
+  return ((0xff << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+
+/**
+ * Convert RGB to hexadecimal color
+ */
+export function rgbToHex(rgb: RGB): HEX {
+  const toHex = (n: number): string => {
+    const hex = Math.round(Math.max(0, Math.min(255, n))).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+
+  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+}
+
+/**
+ * Convert RGB to HSL color space
+ */
+export function rgbToHsl(rgb: RGB): HSL {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const diff = max - min;
+
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+
+  if (diff !== 0) {
+    s = l > 0.5 ? diff / (2 - max - min) : diff / (max + min);
+
+    switch (max) {
+      case b:
+        h = ((r - g) / diff + 4) / 6;
+        break;
+      case g:
+        h = ((b - r) / diff + 2) / 6;
+        break;
+      case r:
+        h = ((g - b) / diff + (g < b ? 6 : 0)) / 6;
+        break;
+    }
+  }
+
+  return {
+    h: Math.round(h * 360),
+    l: Math.round(l * 100),
+    s: Math.round(s * 100),
+  };
+}
+
+/**
+ * Convert RGB to HSV color space
+ */
+export function rgbToHsv(rgb: RGB): HSV {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const diff = max - min;
+
+  let h = 0;
+  const s = max === 0 ? 0 : diff / max;
+  const v = max;
+
+  if (diff !== 0) {
+    switch (max) {
+      case b:
+        h = ((r - g) / diff + 4) / 6;
+        break;
+      case g:
+        h = ((b - r) / diff + 2) / 6;
+        break;
+      case r:
+        h = ((g - b) / diff + (g < b ? 6 : 0)) / 6;
+        break;
+    }
+  }
+
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    v: Math.round(v * 100),
+  };
+}
+
+/**
+ * Convert RGB to LAB color space
+ */
+export function rgbToLab(rgb: RGB): LAB {
+  return xyzToLab(rgbToXyz(rgb));
+}
+
+/**
+ * Convert RGB to XYZ color space
+ * Using sRGB working space and D65 illuminant
+ */
+export function rgbToXyz(rgb: RGB): XYZ {
+  let r = rgb.r / 255;
+  let g = rgb.g / 255;
+  let b = rgb.b / 255;
+
+  // Apply gamma correction
+  r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+  g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+  b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+
+  // Multiply by 100 to get standard XYZ values
+  r *= 100;
+  g *= 100;
+  b *= 100;
+
+  // Apply transformation matrix (sRGB to XYZ)
+  return {
+    x: r * 0.4124564 + g * 0.3575761 + b * 0.1804375,
+    y: r * 0.2126729 + g * 0.7151522 + b * 0.072175,
+    z: r * 0.0193339 + g * 0.119192 + b * 0.9503041,
+  };
+}
+
+/**
+ * Convert XYZ to LAB color space
+ * Using D65 illuminant
+ */
+export function xyzToLab(xyz: XYZ): LAB {
+  const { D65, EPSILON, KAPPA } = ColorConstants;
+
+  // Normalize by reference white
+  const x = xyz.x / D65.X;
+  const y = xyz.y / D65.Y;
+  const z = xyz.z / D65.Z;
+
+  // Apply transformation
+  const fx = x > EPSILON ? Math.cbrt(x) : (KAPPA * x + 16) / 116;
+  const fy = y > EPSILON ? Math.cbrt(y) : (KAPPA * y + 16) / 116;
+  const fz = z > EPSILON ? Math.cbrt(z) : (KAPPA * z + 16) / 116;
+
+  return {
+    a: 500 * (fx - fy),
+    b: 200 * (fy - fz),
+    l: 116 * fy - 16,
+  };
+}
+
+/**
+ * Convert XYZ to RGB color space
+ */
+export function xyzToRgb(xyz: XYZ): RGB {
+  // Normalize by 100
+  const x = xyz.x / 100;
+  const y = xyz.y / 100;
+  const z = xyz.z / 100;
+
+  // Apply inverse transformation matrix (XYZ to sRGB)
+  let r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
+  let g = x * -0.969266 + y * 1.8760108 + z * 0.041556;
+  let b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
+
+  // Apply inverse gamma correction
+  r = r > 0.0031308 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : 12.92 * r;
+  g = g > 0.0031308 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : 12.92 * g;
+  b = b > 0.0031308 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : 12.92 * b;
+
+  return {
+    b: Math.round(Math.max(0, Math.min(255, b * 255))),
+    g: Math.round(Math.max(0, Math.min(255, g * 255))),
+    r: Math.round(Math.max(0, Math.min(255, r * 255))),
+  };
+}

package/src/color/dislike/__tests__/dislike-analyzer.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Tests for DislikeAnalyzer - identifies and fixes universally disliked colors
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { Hct } from "../../hct/index.js";
+import { DislikeAnalyzer } from "../dislike-analyzer";
+
+describe("DislikeAnalyzer", () => {
+  describe("isDisliked", () => {
+    it("should like Monk Skin Tone Scale colors", () => {
+      // From https://skintone.google#/get-started
+      const monkSkinToneScaleColors = [
+        0xfff6ede4, 0xfff3e7db, 0xfff7ead0, 0xffeadaba, 0xffd7bd96, 0xffa07e56,
+        0xff825c43, 0xff604134, 0xff3a312a, 0xff292420,
+      ];
+
+      for (const color of monkSkinToneScaleColors) {
+        const hct = Hct.fromInt(color >>> 0);
+        expect(DislikeAnalyzer.isDisliked(hct)).toBe(false);
+      }
+    });
+
+    it("should dislike bile/waste colors", () => {
+      const unlikableColors = [
+        0xff95884b, // Dark yellow-green (H:96)
+        0xff716b40, // Dark olive (H:100)
+        0xff9a8c00, // Dark yellow-green (H:91)
+        0xff4c4308, // Very dark yellow-green (H:95)
+        0xff464521, // Dark muddy green (H:104)
+      ];
+
+      for (const color of unlikableColors) {
+        const hct = Hct.fromInt(color >>> 0);
+        expect(DislikeAnalyzer.isDisliked(hct)).toBe(true);
+      }
+    });
+
+    it("should identify colors in the bile zone", () => {
+      // Colors with hue 90-111, chroma > 16, tone < 65 should be disliked
+      const bileZoneColor = Hct.from(100, 30, 50); // Middle of bile zone
+      expect(DislikeAnalyzer.isDisliked(bileZoneColor)).toBe(true);
+
+      const borderlineColor = Hct.from(95, 20, 60); // On the edge
+      expect(DislikeAnalyzer.isDisliked(borderlineColor)).toBe(true);
+    });
+
+    it("should not dislike colors outside the bile zone", () => {
+      // Test colors just outside the dislike zone
+      const hueOutsideLow = Hct.from(89, 30, 50); // Hue just below 90
+      const hueOutsideHigh = Hct.from(112, 30, 50); // Hue just above 111
+      const lowChroma = Hct.from(100, 15, 50); // Chroma below 16
+      const highTone = Hct.from(100, 30, 66); // Tone above 65
+
+      expect(DislikeAnalyzer.isDisliked(hueOutsideLow)).toBe(false);
+      expect(DislikeAnalyzer.isDisliked(hueOutsideHigh)).toBe(false);
+      expect(DislikeAnalyzer.isDisliked(lowChroma)).toBe(false);
+      expect(DislikeAnalyzer.isDisliked(highTone)).toBe(false);
+    });
+
+    it("should like neutral colors even in yellow-green hue range", () => {
+      // Low chroma colors should be liked even if hue is in the bile range
+      const neutral = Hct.from(100, 5, 50); // Very low chroma
+      expect(DislikeAnalyzer.isDisliked(neutral)).toBe(false);
+    });
+
+    it("should like light colors even with bile hue", () => {
+      // High tone colors should be liked
+      const lightColor = Hct.from(100, 30, 75); // Light tone
+      expect(DislikeAnalyzer.isDisliked(lightColor)).toBe(false);
+    });
+  });
+
+  describe("fixIfDisliked", () => {
+    it("should fix disliked colors by lightening them", () => {
+      const unlikableColors = [
+        0xff95884b,
+        0xff716b40,
+        0xff9a8c00, // Changed to ensure hue is in range
+        0xff4c4308,
+        0xff464521,
+      ];
+
+      for (const color of unlikableColors) {
+        const hct = Hct.fromInt(color >>> 0);
+        expect(DislikeAnalyzer.isDisliked(hct)).toBe(true);
+
+        const fixed = DislikeAnalyzer.fixIfDisliked(hct);
+        expect(DislikeAnalyzer.isDisliked(fixed)).toBe(false);
+
+        // Check that fix preserves hue and chroma, only changes tone
+        expect(fixed.hue).toBeCloseTo(hct.hue, 0);
+        expect(fixed.chroma).toBeCloseTo(hct.chroma, 0);
+        expect(fixed.tone).toBeCloseTo(70, 0); // Within 1 unit
+      }
+    });
+
+    it("should not change liked colors", () => {
+      const likedColor = Hct.from(200, 50, 50); // Blue, clearly liked
+      const fixed = DislikeAnalyzer.fixIfDisliked(likedColor);
+
+      expect(fixed.toInt()).toBe(likedColor.toInt());
+      expect(fixed).toBe(likedColor); // Should return same instance
+    });
+
+    it("should fix colors at tone 67 to tone 70", () => {
+      const color = Hct.from(100, 50, 67); // Above threshold but close
+      expect(DislikeAnalyzer.isDisliked(color)).toBe(false);
+
+      const fixed = DislikeAnalyzer.fixIfDisliked(color);
+      expect(fixed.toInt()).toBe(color.toInt());
+    });
+
+    it("should handle edge case at tone 64", () => {
+      const color = Hct.from(100, 30, 64); // Just below threshold
+      expect(DislikeAnalyzer.isDisliked(color)).toBe(true);
+
+      const fixed = DislikeAnalyzer.fixIfDisliked(color);
+      expect(fixed.tone).toBeCloseTo(70, 0); // Within 1 unit
+      expect(DislikeAnalyzer.isDisliked(fixed)).toBe(false);
+    });
+  });
+
+  describe("hex color helpers", () => {
+    it("should check hex colors for dislike", () => {
+      expect(DislikeAnalyzer.isDislikedHex("#95884B")).toBe(true);
+      expect(DislikeAnalyzer.isDislikedHex("#0080ff")).toBe(false);
+    });
+
+    it("should fix disliked hex colors", () => {
+      const disliked = "#95884B";
+      const fixed = DislikeAnalyzer.fixIfDislikedHex(disliked);
+
+      expect(fixed).not.toBe(disliked);
+      expect(DislikeAnalyzer.isDislikedHex(fixed)).toBe(false);
+    });
+
+    it("should return same hex for liked colors", () => {
+      const liked = "#0080ff";
+      const fixed = DislikeAnalyzer.fixIfDislikedHex(liked);
+
+      expect(fixed).toBe(liked);
+    });
+  });
+
+  describe("batch operations", () => {
+    it("should analyze batch of colors", () => {
+      const colors = [
+        Hct.from(100, 30, 50), // Disliked
+        Hct.from(200, 50, 50), // Liked
+        Hct.from(95, 20, 60), // Disliked
+        Hct.from(300, 40, 40), // Liked
+      ];
+
+      const analysis = DislikeAnalyzer.analyzeBatch(colors);
+
+      expect(analysis.total).toBe(4);
+      expect(analysis.disliked).toBe(2);
+      expect(analysis.percentage).toBe(50);
+      expect(analysis.dislikedIndices).toEqual([0, 2]);
+    });
+
+    it("should fix batch of colors", () => {
+      const colors = [
+        Hct.from(100, 30, 50), // Disliked
+        Hct.from(200, 50, 50), // Liked
+        Hct.from(95, 20, 60), // Disliked
+      ];
+
+      const fixed = DislikeAnalyzer.fixBatch(colors);
+
+      expect(fixed).toHaveLength(3);
+
+      // First color should be fixed
+      expect(fixed[0].tone).toBeCloseTo(70, 0); // Within 1 unit
+      expect(DislikeAnalyzer.isDisliked(fixed[0])).toBe(false);
+
+      // Second color should be unchanged
+      expect(fixed[1].toInt()).toBe(colors[1].toInt());
+
+      // Third color should be fixed
+      expect(fixed[2].tone).toBeCloseTo(70, 0); // Within 1 unit
+      expect(DislikeAnalyzer.isDisliked(fixed[2])).toBe(false);
+    });
+
+    it("should handle empty batch", () => {
+      const analysis = DislikeAnalyzer.analyzeBatch([]);
+
+      expect(analysis.total).toBe(0);
+      expect(analysis.disliked).toBe(0);
+      expect(analysis.percentage).toBeNaN(); // 0/0
+      expect(analysis.dislikedIndices).toEqual([]);
+
+      const fixed = DislikeAnalyzer.fixBatch([]);
+      expect(fixed).toEqual([]);
+    });
+
+    it("should handle batch with all disliked colors", () => {
+      const colors = [
+        Hct.from(100, 30, 50),
+        Hct.from(95, 20, 60),
+        Hct.from(105, 25, 45),
+      ];
+
+      const analysis = DislikeAnalyzer.analyzeBatch(colors);
+      expect(analysis.disliked).toBe(3);
+      expect(analysis.percentage).toBe(100);
+
+      const fixed = DislikeAnalyzer.fixBatch(colors);
+      const fixedAnalysis = DislikeAnalyzer.analyzeBatch(fixed);
+      expect(fixedAnalysis.disliked).toBe(0);
+    });
+  });
+
+  describe("real-world color examples", () => {
+    it("should handle olive green colors correctly", () => {
+      // Olive greens that might appear in military/outdoor themes
+      const oliveGreen = Hct.fromInt(0xff556b2f >>> 0); // DarkOliveGreen
+      const isOliveDisliked = DislikeAnalyzer.isDisliked(oliveGreen);
+
+      // This specific olive might be on the edge - test behavior
+      if (isOliveDisliked) {
+        const fixed = DislikeAnalyzer.fixIfDisliked(oliveGreen);
+        expect(fixed.tone).toBeGreaterThan(oliveGreen.tone);
+      }
+    });
+
+    it("should not dislike pleasant greens", () => {
+      // Forest green, mint green, etc. should be liked
+      const forestGreen = Hct.fromInt(0xff228b22 >>> 0);
+      const mintGreen = Hct.fromInt(0xff98ff98 >>> 0);
+
+      expect(DislikeAnalyzer.isDisliked(forestGreen)).toBe(false);
+      expect(DislikeAnalyzer.isDisliked(mintGreen)).toBe(false);
+    });
+
+    it("should handle brand colors appropriately", () => {
+      // Some brand yellows might be in the danger zone
+      const brightYellow = Hct.fromInt(0xffffd700 >>> 0); // Gold
+      const mustardYellow = Hct.fromInt(0xffffdb58 >>> 0); // Mustard
+
+      // These should be light enough to not be disliked
+      expect(DislikeAnalyzer.isDisliked(brightYellow)).toBe(false);
+      expect(DislikeAnalyzer.isDisliked(mustardYellow)).toBe(false);
+    });
+  });
+});