@versatiles/style 5.9.0 → 5.9.2

package/src/color/hsv.test.ts

@@ -1,169 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { HSV } from './hsv.js';
-import { HSL } from './hsl.js';
-import { RGB } from './rgb.js';
-
-describe('HSV Class', () => {
-	it('constructor initializes values correctly with clamping', () => {
-		const color = new HSV(400, 120, 120, 2);
-		expect(color.asArray()).toStrictEqual([40, 100, 100, 1]);
-
-		const colorNegative = new HSV(-60, -10, -10, -1);
-		expect(colorNegative.asArray()).toStrictEqual([300, 0, 0, 0]);
-	});
-
-	it('asArray returns correct array representation', () => {
-		const color = new HSV(120, 50, 50, 0.5);
-		expect(color.asArray()).toStrictEqual([120, 50, 50, 0.5]);
-	});
-
-	it('clone returns a new instance with identical values', () => {
-		const color = new HSV(180, 70, 70, 0.7);
-		const clone = color.clone();
-		expect(clone).toBeInstanceOf(HSV);
-		expect(clone).toEqual(color);
-		expect(clone).not.toBe(color);
-	});
-
-	describe('asString', () => {
-		it('converts fully saturated colors correctly', () => {
-			expect(new HSV(0, 100, 100).asString()).toBe('hsl(0,100%,50%)');
-			expect(new HSV(120, 100, 100).asString()).toBe('hsl(120,100%,50%)');
-			expect(new HSV(240, 100, 100).asString()).toBe('hsl(240,100%,50%)');
-		});
-
-		it('handles partially saturated colors', () => {
-			expect(new HSV(60, 50, 100).asString()).toBe('hsl(60,100%,75%)');
-			expect(new HSV(300, 25, 50).asString()).toBe('hsl(300,14%,44%)');
-		});
-
-		it('handles achromatic (grey) colors', () => {
-			expect(new HSV(0, 0, 0).asString()).toBe('hsl(0,0%,0%)');
-			expect(new HSV(0, 0, 50).asString()).toBe('hsl(0,0%,50%)');
-			expect(new HSV(0, 0, 100).asString()).toBe('hsl(0,0%,100%)');
-		});
-
-		it('handles hue wrapping and extreme values', () => {
-			expect(new HSV(-60, 100, 100).asString()).toBe('hsl(300,100%,50%)');
-			expect(new HSV(420, 100, 100).asString()).toBe('hsl(60,100%,50%)');
-		});
-
-		it('handles alpha transparency', () => {
-			expect(new HSV(0, 100, 100, 0.5).asString()).toBe('hsla(0,100%,50%,0.5)');
-			expect(new HSV(120, 100, 100, 0.25).asString()).toBe('hsla(120,100%,50%,0.25)');
-			expect(new HSV(240, 100, 100, 1).asString()).toBe('hsl(240,100%,50%)');
-		});
-
-		it('produces consistent results for repeated calls', () => {
-			const color = new HSV(60, 50, 50);
-			expect(color.asString()).toBe('hsl(60,33%,38%)');
-			expect(color.asString()).toBe('hsl(60,33%,38%)');
-		});
-	});
-
-	describe('color conversion', () => {
-		it('asHSL converts HSV to HSL correctly', () => {
-			function check(input: [number, number, number], output: [number, number, number]) {
-				const hsv = new HSV(...input);
-				const hsl = hsv.asHSL();
-				expect(hsl).toBeInstanceOf(HSL);
-				expect(hsl.asArray().map(Math.round)).toStrictEqual([...output, 1]);
-
-				expect(hsv.asHex()).toStrictEqual(hsl.asHex());
-			}
-
-			check([10, 0, 0], [10, 0, 0]);
-			check([11, 0, 50], [11, 0, 50]);
-			check([12, 0, 100], [12, 0, 100]);
-			check([13, 50, 0], [13, 0, 0]);
-			check([14, 50, 50], [14, 33, 38]);
-			check([15, 50, 100], [15, 100, 75]);
-			check([16, 100, 0], [16, 0, 0]);
-			check([17, 100, 50], [17, 100, 25]);
-			check([18, 100, 100], [18, 100, 50]);
-		});
-
-		it('asRGB converts HSV to RGB correctly', () => {
-			const color = new HSV(120, 100, 100);
-			const rgb = color.asRGB();
-			expect(rgb).toBeInstanceOf(RGB);
-			expect(rgb.asArray().map((value) => Math.round(value))).toStrictEqual([0, 255, 0, 1]);
-		});
-
-		it('asHSV and toHSV return the same instance or clone', () => {
-			const color = new HSV(240, 100, 50, 1);
-			expect(color.asHSV()).toStrictEqual(color);
-			expect(color.toHSV()).toStrictEqual(color);
-		});
-
-		it('asRGB conversion S and V', () => {
-			function check(input: [number, number, number], output: [number, number, number]) {
-				const color = new HSV(...input);
-				const rgb = color.asRGB();
-				expect(rgb.asArray().map((value) => Math.round(value))).toStrictEqual([...output, 1]);
-			}
-
-			check([10, 0, 0], [0, 0, 0]);
-			check([11, 0, 50], [128, 128, 128]);
-			check([12, 0, 100], [255, 255, 255]);
-			check([13, 50, 0], [0, 0, 0]);
-			check([14, 50, 50], [128, 79, 64]);
-			check([15, 50, 100], [255, 159, 128]);
-			check([16, 100, 0], [0, 0, 0]);
-			check([17, 100, 50], [128, 36, 0]);
-			check([18, 100, 100], [255, 77, 0]);
-		});
-
-		it('asRGB conversion H', () => {
-			function check(hue: number, output: string) {
-				const color = new HSV(hue, 100, 100);
-				expect(color.asRGB().asHex()).toBe(output);
-			}
-
-			check(-1, '#FF0004');
-			check(0, '#FF0000');
-			check(1, '#FF0400');
-			check(30, '#FF8000');
-			check(60, '#FFFF00');
-			check(90, '#80FF00');
-			check(120, '#00FF00');
-			check(150, '#00FF80');
-			check(180, '#00FFFF');
-			check(210, '#0080FF');
-			check(240, '#0000FF');
-			check(270, '#8000FF');
-			check(300, '#FF00FF');
-			check(330, '#FF0080');
-			check(359, '#FF0004');
-			check(360, '#FF0000');
-			check(361, '#FF0400');
-		});
-	});
-
-	describe('parse errors and validations', () => {
-		it('constructor clamps out-of-bound values', () => {
-			const color = new HSV(400, 150, 150, 2);
-			expect(color.asArray()).toStrictEqual([40, 100, 100, 1]);
-		});
-
-		it('negative values are handled correctly', () => {
-			const color = new HSV(-360, -50, -50, -1);
-			expect(color.asArray()).toStrictEqual([0, 0, 0, 0]);
-		});
-	});
-
-	describe('fade', () => {
-		it('reduces alpha correctly', () => {
-			const color = new HSV(120, 50, 50, 0.8);
-			expect(color.fade(0.5).asArray()).toStrictEqual([120, 50, 50, 0.4]); // Alpha reduced by 50%
-		});
-
-		it('handles edge cases for fading', () => {
-			const opaque = new HSV(0, 50, 50, 1);
-			expect(opaque.fade(1).asArray()).toStrictEqual([0, 50, 50, 0]); // Fully faded to transparent
-
-			const transparent = new HSV(0, 50, 50, 0);
-			expect(transparent.fade(0.5).asArray()).toStrictEqual([0, 50, 50, 0]); // Remains fully transparent
-		});
-	});
-});

package/src/color/hsv.ts

@@ -1,189 +0,0 @@
-import { Color } from './abstract.js';
-import { HSL } from './hsl.js';
-import randomColor, { RandomColorOptions } from './random.js';
-import { RGB } from './rgb.js';
-import { clamp, mod } from './utils.js';
-
-/**
- * Represents a color in the HSV (Hue, Saturation, Value) color space.
- * Extends the base `Color` class.
- */
-export class HSV extends Color {
-	/**
-	 * The hue component of the color, in the range [0, 360].
-	 */
-	readonly h: number;
-
-	/**
-	 * The saturation component of the color, in the range [0, 100].
-	 */
-	readonly s: number;
-
-	/**
-	 * The value (brightness) component of the color, in the range [0, 100].
-	 */
-	readonly v: number;
-
-	/**
-	 * The alpha (opacity) component of the color, in the range [0, 1].
-	 */
-	readonly a: number;
-
-	/**
-	 * Constructs a new HSV color.
-	 * @param h - The hue component, in the range [0, 360].
-	 * @param s - The saturation component, in the range [0, 100].
-	 * @param v - The value (brightness) component, in the range [0, 100].
-	 * @param a - The alpha (opacity) component, in the range [0, 1]. Defaults to 1.
-	 */
-	constructor(h: number, s: number, v: number, a: number = 1) {
-		super();
-		this.h = mod(h, 360);
-		this.s = clamp(s, 0, 100);
-		this.v = clamp(v, 0, 100);
-		this.a = clamp(a, 0, 1);
-	}
-
-	/**
-	 * Returns the HSV color as an array of numbers.
-	 * @returns An array containing the hue, saturation, value, and alpha components.
-	 */
-	asArray(): [number, number, number, number] {
-		return [this.h, this.s, this.v, this.a];
-	}
-
-	/**
-	 * Returns a new HSV color with the components rounded to the nearest integer.
-	 * @returns A new HSV color with rounded components.
-	 */
-	round(): HSV {
-		return new HSV(Math.round(this.h), Math.round(this.s), Math.round(this.v), Math.round(this.a * 1000) / 1000);
-	}
-
-	/**
-	 * Returns the color as a string representation.
-	 * @returns A string representation of the color.
-	 */
-	asString(): string {
-		return this.asHSL().asString();
-	}
-
-	/**
-	 * Creates a new HSV color that is a copy of the current color.
-	 * @returns A new HSV color that is a clone of the current color.
-	 */
-	clone(): HSV {
-		return new HSV(this.h, this.s, this.v, this.a);
-	}
-
-	/**
-	 * Converts the HSV color to an HSL color.
-	 * @returns An HSL representation of the color.
-	 */
-	asHSL(): HSL {
-		const s = this.s / 100;
-		const v = this.v / 100;
-		const k = (2 - s) * v;
-		const q = k < 1 ? k : 2 - k;
-		return new HSL(this.h, q === 0 ? 0 : (100 * s * v) / q, (100 * k) / 2, this.a);
-	}
-
-	/**
-	 * Returns the current HSV color.
-	 * @returns The current HSV color.
-	 */
-	asHSV(): HSV {
-		return this.clone();
-	}
-
-	/**
-	 * Returns the current HSV color.
-	 * @returns The current HSV color.
-	 */
-	toHSV(): HSV {
-		return this;
-	}
-
-	/**
-	 * Converts the HSV color to an RGB color.
-	 * @returns An RGB representation of the color.
-	 */
-	asRGB(): RGB {
-		const h = this.h / 360; // Normalize h to range [0, 1]
-		const s = this.s / 100; // Normalize s to range [0, 1]
-		const v = this.v / 100; // Normalize v to range [0, 1]
-
-		let r = 0,
-			g = 0,
-			b = 0;
-
-		if (s === 0) {
-			// Achromatic (grey)
-			r = g = b = v;
-		} else {
-			const i = Math.floor(h * 6); // Determine the sector of the color wheel
-			const f = h * 6 - i; // Fractional part of h * 6
-			const p = v * (1 - s);
-			const q = v * (1 - s * f);
-			const t = v * (1 - s * (1 - f));
-
-			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;
-			}
-		}
-
-		// Convert to RGB in the 0-255 range and return
-		return new RGB(r * 255, g * 255, b * 255, this.a);
-	}
-
-	/**
-	 * Fades the color by a given value.
-	 * @param value - The amount to fade the color by, in the range [0, 1].
-	 * @returns A new HSV color with the alpha component faded by the given value.
-	 */
-	fade(value: number): HSV {
-		return new HSV(this.h, this.s, this.v, this.a * (1 - value));
-	}
-
-	/**
-	 * Sets the hue component of the color.
-	 * @param value - The new hue value, in the range [0, 360].
-	 * @returns A new HSV color with the updated hue component.
-	 */
-	setHue(value: number): HSV {
-		return new HSV(value, this.s, this.v, this.a);
-	}
-
-	static randomColor(options?: RandomColorOptions): HSV {
-		return randomColor(options);
-	}
-}

package/src/color/index.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Color } from './index.js';
-import { HSL } from './hsl.js';
-import { HSV } from './hsv.js';
-import { RGB } from './rgb.js';
-
-describe('Color Conversions', () => {
-	const scenarios: [number, number, number, number][] = [
-		[-100, 14, 15, 0],
-		[0, 0, 0, 0.1],
-		[100, 0, 50, 0.2],
-		[200, 0, 100, 0.3],
-		[300, 50, 0, 0.4],
-		[400, 50, 50, 0.5],
-		[500, 50, 100, 0.6],
-		[600, 100, 0, 0.7],
-		[700, 100, 50, 0.8],
-		[800, 100, 100, 0.9],
-		[900, 12, 13, 1.0],
-	];
-	it('test HSV -> HSL -> RGB', () => {
-		for (const v of scenarios) {
-			const hsv = new HSV(...v);
-			expect(hsv.a).toEqual(v[3]);
-			const hsl = hsv.asHSL();
-			const a1 = hsv.asRGB().asArray();
-			const a2 = hsl.asRGB().asArray();
-			for (let i = 0; i < 4; i++) expect(a1[i]).toBeCloseTo(a2[i]);
-		}
-	});
-
-	it('test HSL -> HSV -> RGB', () => {
-		for (const v of scenarios) {
-			const hsl = new HSL(...v);
-			expect(hsl.a).toEqual(v[3]);
-			const hsv = hsl.asHSV();
-			const a1 = hsv.asRGB().asArray();
-			const a2 = hsl.asRGB().asArray();
-			for (let i = 0; i < 4; i++) expect(a1[i]).toBeCloseTo(a2[i]);
-		}
-	});
-});
-
-describe('Color.parse', () => {
-	it('parses hexadecimal color strings correctly', () => {
-		const color = Color.parse('#ff8040');
-		expect(color).toBeInstanceOf(RGB);
-		expect(color.asArray()).toStrictEqual([255, 128, 64, 1]);
-
-		const colorWithAlpha = Color.parse('#ff80407f');
-		expect(colorWithAlpha).toBeInstanceOf(RGB);
-		expect(colorWithAlpha.asHex()).toStrictEqual('#FF80407F');
-	});
-
-	it('parses RGB strings correctly', () => {
-		const color = Color.parse('rgb(255, 128, 64)');
-		expect(color).toBeInstanceOf(RGB);
-		expect(color.asArray()).toStrictEqual([255, 128, 64, 1]);
-
-		const colorWithAlpha = Color.parse('rgba(255, 128, 64, 0.5)');
-		expect(colorWithAlpha).toBeInstanceOf(RGB);
-		expect(colorWithAlpha.asArray()).toStrictEqual([255, 128, 64, 0.5]);
-	});
-
-	it('parses HSL strings correctly', () => {
-		const color = Color.parse('hsl(120, 50%, 50%)');
-		expect(color).toBeInstanceOf(HSL);
-		expect(color.asArray()).toStrictEqual([120, 50, 50, 1]);
-
-		const colorWithAlpha = Color.parse('hsla(120, 50%, 50%, 0.5)');
-		expect(colorWithAlpha).toBeInstanceOf(HSL);
-		expect(colorWithAlpha.asArray()).toStrictEqual([120, 50, 50, 0.5]);
-	});
-
-	it('throws an error for unsupported formats', () => {
-		expect(() => Color.parse('invalid color string')).toThrow(
-			'Color.parse: Unknown color format "invalid color string"'
-		);
-	});
-});
-
-describe('Color Class Properties', () => {
-	it('Color.HSL is accessible', () => {
-		expect(Color.HSL).toBe(HSL);
-	});
-
-	it('Color.HSV is accessible', () => {
-		expect(Color.HSV).toBe(HSV);
-	});
-
-	it('Color.RGB is accessible', () => {
-		expect(Color.RGB).toBe(RGB);
-	});
-});
-
-describe('Exported Module', () => {
-	it('named export is Color', async () => {
-		const module = await import('./index.js');
-		expect(module.Color).toBe(Color);
-	});
-});
-
-describe('Color Transformation Methods', () => {
-	it('gamma() applies gamma correction', () => {
-		const color = Color.parse('#808080');
-		expect(color.gamma(2.2).asString()).toBe('rgb(56,56,56)');
-	});
-
-	it('gamma() works from HSL', () => {
-		const hsl = new HSL(120, 50, 50, 1);
-		expect(hsl.gamma(2.2).asString()).toBe('rgb(12,135,12)');
-	});
-
-	it('contrast() adjusts contrast', () => {
-		const color = Color.parse('#FF8040');
-		expect(color.contrast(1.5).asString()).toBe('rgb(255,128,32)');
-	});
-
-	it('contrast() works from HSV', () => {
-		const hsv = new HSV(180, 50, 50, 1);
-		expect(hsv.contrast(1.5).asString()).toBe('rgb(32,128,128)');
-	});
-
-	it('brightness() works from HSL', () => {
-		const hsl = new HSL(240, 100, 50, 1);
-		expect(hsl.brightness(0.3).asString()).toBe('rgb(77,77,255)');
-	});
-
-	it('lighten() works from HSL', () => {
-		const hsl = new HSL(0, 100, 30, 1);
-		expect(hsl.lighten(0.2).asString()).toBe('rgb(173,51,51)');
-	});
-
-	it('darken() works from HSV', () => {
-		const hsv = new HSV(60, 100, 80, 1);
-		expect(hsv.darken(0.3).asString()).toBe('rgb(143,143,0)');
-	});
-
-	it('tint() blends with a tint color', () => {
-		const color = Color.parse('#FF0000');
-		const tintColor = Color.parse('#0000FF');
-		expect(color.tint(0.5, tintColor).asString()).toBe('rgb(128,0,128)');
-	});
-
-	it('tint() works from HSL', () => {
-		const hsl = new HSL(0, 100, 50, 1);
-		const tintColor = new HSL(120, 100, 50, 1);
-		expect(hsl.tint(0.5, tintColor).asString()).toBe('rgb(128,128,0)');
-	});
-
-	it('blend() blends with another color', () => {
-		const color1 = Color.parse('#FF0000');
-		const color2 = Color.parse('#0000FF');
-		expect(color1.blend(0.5, color2).asString()).toBe('rgb(128,0,128)');
-	});
-
-	it('blend() works from HSV', () => {
-		const hsv1 = new HSV(0, 100, 100, 1);
-		const hsv2 = new HSV(240, 100, 100, 1);
-		expect(hsv1.blend(0.3, hsv2).asString()).toBe('rgb(179,0,77)');
-	});
-
-	it('setHue() changes the hue', () => {
-		const color = Color.parse('#FF0000');
-		expect(color.setHue(180).asString()).toBe('hsl(180,100%,50%)');
-	});
-
-	it('invertLuminosity() inverts from HSV', () => {
-		const hsv = new HSV(200, 50, 60, 1);
-		expect(hsv.invertLuminosity().asString()).toBe('hsl(200,33%,55%)');
-	});
-
-	it('rotateHue() rotates from RGB', () => {
-		const rgb = new RGB(255, 0, 0, 1);
-		expect(rgb.rotateHue(120).asString()).toBe('hsl(120,100%,50%)');
-	});
-
-	it('saturate() increases saturation from HSV', () => {
-		const hsv = new HSV(100, 30, 70, 1);
-		expect(hsv.saturate(1.5).asString()).toBe('hsl(100,65%,60%)');
-	});
-
-	it('invert() inverts from HSL', () => {
-		const hsl = new HSL(180, 100, 50, 1);
-		expect(hsl.invert().asString()).toBe('rgb(255,0,0)');
-	});
-});

package/src/color/index.ts

@@ -1,37 +0,0 @@
-import { Color } from './abstract.js';
-import { HSL } from './hsl.js';
-import { HSV } from './hsv.js';
-import { RGB } from './rgb.js';
-
-Color.parse = function (input: string | Color): Color {
-	if (input instanceof Color) return input;
-
-	input = input.trim().toLowerCase();
-
-	if (input.startsWith('#')) return RGB.parse(input);
-
-	const prefix = input.replace(/\d.*/, '').trim().toLowerCase();
-
-	switch (prefix) {
-		case 'rgb(':
-		case 'rgba(':
-			return RGB.parse(input);
-		case 'hsl(':
-		case 'hsla(':
-			return HSL.parse(input);
-		default:
-			throw new Error(
-				`Color.parse: Unknown color format "${input}". Expected formats: "#RRGGBB", "#RGB", "rgb(...)", "rgba(...)", "hsl(...)", or "hsla(...)".`
-			);
-	}
-};
-
-Color.HSL = HSL;
-Color.HSV = HSV;
-Color.RGB = RGB;
-
-export type { RandomColorOptions } from './random.js';
-export type { HSL } from './hsl.js';
-export type { HSV } from './hsv.js';
-export type { RGB } from './rgb.js';
-export { Color };

package/src/color/random.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { HSV } from './hsv.js';
-import type { RandomColorOptions } from './random.js';
-import randomColor from './random.js';
-
-describe('RandomColor', () => {
-	it('constructor initializes without errors', () => {
-		expect(randomColor).toBeDefined();
-	});
-
-	describe('Color.random', () => {
-		it('generates random HSV colors', () => {
-			const random = randomColor();
-			expect(random).toBeInstanceOf(HSV);
-			const array = random.asArray();
-			expect(array[0]).toBeGreaterThanOrEqual(0);
-			expect(array[0]).toBeLessThanOrEqual(360);
-			expect(array[1]).toBeGreaterThanOrEqual(0);
-			expect(array[1]).toBeLessThanOrEqual(100);
-			expect(array[2]).toBeGreaterThanOrEqual(0);
-			expect(array[2]).toBeLessThanOrEqual(100);
-		});
-
-		it('supports options for generating random colors', () => {
-			const random = randomColor({ hue: 'red', luminosity: 'bright' });
-			expect(random).toBeInstanceOf(HSV);
-			// Additional checks based on the options provided can be added here
-		});
-	});
-
-	describe('randomColor method', () => {
-		it('returns correct color string for some test cases', () => {
-			function t(options: RandomColorOptions): string {
-				return randomColor(options).asHSL().asString();
-			}
-			expect(t({ seed: 'testSeed', hue: 'red' })).toBe('hsl(356,90%,30%)');
-			expect(t({ seed: 'testSeed', hue: 120 })).toBe('hsl(120,92%,26%)');
-			expect(t({ seed: 'testSeed', luminosity: 'dark' })).toBe('hsl(185,98%,19%)');
-			expect(t({ seed: 'testSeed', luminosity: 12 })).toBe('hsl(185,90%,6%)');
-			expect(t({ seed: 'testSeed', saturation: 'strong' })).toBe('hsl(185,100%,48%)');
-			expect(t({ seed: 'testSeed', opacity: 0.5 })).toBe('hsla(185,90%,23%,0.5)');
-			expect(t({ seed: 'testSeed' })).toBe('hsl(185,90%,23%)');
-		});
-
-		it('generates light colors with luminosity: "light"', () => {
-			const color = randomColor({ seed: 'lightSeed', luminosity: 'light' });
-			const hsv = color.asArray();
-			// Light colors should have higher brightness values
-			expect(hsv[2]).toBeGreaterThan(50);
-			expect(color).toBeInstanceOf(HSV);
-		});
-
-		it('generates random luminosity colors with luminosity: "random"', () => {
-			const color = randomColor({ seed: 'randomSeed', luminosity: 'random' });
-			const hsv = color.asArray();
-			// Random luminosity can be anywhere from 0-100
-			expect(hsv[2]).toBeGreaterThanOrEqual(0);
-			expect(hsv[2]).toBeLessThanOrEqual(100);
-			expect(color).toBeInstanceOf(HSV);
-		});
-
-		it('generates light saturation with luminosity: "light"', () => {
-			// Test light luminosity affects saturation picking
-			const color1 = randomColor({ seed: 'lightTest1', luminosity: 'light', hue: 'blue' });
-			const color2 = randomColor({ seed: 'lightTest2', luminosity: 'light', hue: 'green' });
-			expect(color1).toBeInstanceOf(HSV);
-			expect(color2).toBeInstanceOf(HSV);
-		});
-
-		it('generates colors with various saturation options', () => {
-			const weak = randomColor({ seed: 'satTest', saturation: 'weak' });
-			const strong = randomColor({ seed: 'satTest', saturation: 'strong' });
-
-			expect(weak).toBeInstanceOf(HSV);
-			expect(strong).toBeInstanceOf(HSV);
-			// Strong saturation should have higher saturation values
-			expect(strong.s).toBeGreaterThan(80);
-		});
-
-		it('generates colors with all hue name options', () => {
-			const hues: Array<string | number> = [
-				'red',
-				'orange',
-				'yellow',
-				'green',
-				'blue',
-				'purple',
-				'pink',
-				'monochrome',
-				180,
-			];
-
-			hues.forEach((hue) => {
-				const color = randomColor({ seed: `hue-${hue}`, hue });
-				expect(color).toBeInstanceOf(HSV);
-			});
-		});
-
-		it('consistent color generation with a seed', () => {
-			const color1 = randomColor({ seed: 'consistentSeed' });
-			const color2 = randomColor({ seed: 'consistentSeed' });
-			expect(color1.asHex()).toBe(color2.asHex());
-		});
-
-		it('different color generation without a seed', () => {
-			const color1 = randomColor({ seed: 'seed1' });
-			const color2 = randomColor({ seed: 'seed2' });
-			expect(color1.asHex()).not.toBe(color2.asHex());
-		});
-	});
-});