@versatiles/style 5.7.0 → 5.8.0

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@versatiles/style",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "description": "Generate StyleJSON for MapLibre",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=20.0.0 <24.0.0"
+    }
+  },
   "scripts": {
     "check": "npm run lint && npm run build && npm run test ",
     "build": "rm -rf release; npm run build-browser && npm run build-node && npm run build-styles && npm run build-sprites && npm run doc",
-    "build-browser": "rollup --configPlugin '@rollup/plugin-typescript={sourceMap:false}' -c --environment BUILD:browser && $(cd release/versatiles-style; tar -cf - versatiles-style.* | gzip -9 > ../versatiles-style.tar.gz)",
-    "build-node": "rm -rf dist && rollup --configPlugin '@rollup/plugin-typescript={sourceMap:false}' -c --environment BUILD:node && chmod +x dist/index.js && rm -r dist/declaration",
+    "build-browser": "rollup -c --environment BUILD:browser && $(cd release/versatiles-style; tar -cf - versatiles-style.* | gzip -9 > ../versatiles-style.tar.gz)",
+    "build-node": "rm -rf dist && rollup -c --environment BUILD:node && chmod +x dist/index.js && rm -r dist/declaration",
     "build-styles": "tsx scripts/build-styles.ts",
     "build-sprites": "tsx scripts/build-sprites.ts",
     "dev": "tsx scripts/dev.ts",
@@ -20,8 +26,8 @@
     "prepack": "npm run build",
     "release": "vrt release-npm",
     "test": "npm run test-typescript",
-    "test-coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
-    "test-typescript": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test-coverage": "vitest run --coverage",
+    "test-typescript": "vitest run",
     "upgrade": "vrt deps-upgrade"
   },
   "repository": {
@@ -32,7 +38,6 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@versatiles/style": "^5.6.0",
     "brace-expansion": "^4.0.1"
   },
   "files": [
@@ -40,37 +45,33 @@
     "src/*"
   ],
   "devDependencies": {
-    "@maplibre/maplibre-gl-native": "^6.1.0",
-    "@maplibre/maplibre-gl-style-spec": "^23.3.0",
-    "@rollup/plugin-commonjs": "^28.0.6",
-    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@maplibre/maplibre-gl-native": "^6.2.0",
+    "@maplibre/maplibre-gl-style-spec": "^24.3.1",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^12.1.3",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/bin-pack": "^1.0.3",
     "@types/brace-expansion": "^1.1.2",
-    "@types/inquirer": "^9.0.8",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^24.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^24.10.1",
     "@types/tar-stream": "^3.1.4",
-    "@typescript-eslint/eslint-plugin": "^8.35.0",
-    "@typescript-eslint/parser": "^8.35.0",
-    "@versatiles/release-tool": "^2.4.2",
+    "@typescript-eslint/eslint-plugin": "^8.47.0",
+    "@typescript-eslint/parser": "^8.47.0",
+    "@versatiles/release-tool": "^2.4.5",
+    "@vitest/coverage-v8": "^4.0.10",
     "bin-pack": "^1.0.2",
-    "esbuild": "^0.25.5",
-    "eslint": "^9.29.0",
-    "inquirer": "^12.6.3",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-ts-webcompat-resolver": "^1.0.1",
-    "rollup": "^4.44.0",
-    "rollup-plugin-dts": "^6.2.1",
-    "rollup-plugin-sourcemaps2": "^0.5.2",
-    "sharp": "^0.34.2",
+    "esbuild": "^0.27.0",
+    "eslint": "^9.39.1",
+    "inquirer": "^13.0.1",
+    "rollup": "^4.53.3",
+    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-sourcemaps2": "^0.5.4",
+    "sharp": "^0.34.5",
     "tar-stream": "^3.1.7",
-    "ts-jest": "^29.4.0",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.35.0"
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^4.0.10"
   }
 }

package/src/color/hsl.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it, beforeEach } from 'vitest';
 import { HSL } from './hsl.js';
 import { HSV } from './hsv.js';
 import { RGB } from './rgb.js';
@@ -6,23 +7,23 @@ describe('HSL Class', () => {
 
 	describe('constructor', () => {
 
-		test('should initialize small HSL values correctly', () => {
+		it('should initialize small HSL values correctly', () => {
 			const color = new HSL(10, 20, 30, 0.4);
 			expect(color.asArray()).toStrictEqual([10, 20, 30, 0.4]);
 		});
 
-		test('should initialize big HSL values correctly', () => {
+		it('should initialize big HSL values correctly', () => {
 			const color = new HSL(400, 120, 120, 2);
 			expect(color.asArray()).toStrictEqual([40, 100, 100, 1]);
 		});
 
-		test('should initialize small HSL values correctly', () => {
+		it('should initialize small HSL values correctly', () => {
 			const color = new HSL(-60, -10, -10, -1);
 			expect(color.asArray()).toStrictEqual([300, 0, 0, 0]);
 		});
 	})
 
-	test('clone should return a new HSL instance with identical values', () => {
+	it('clone should return a new HSL instance with identical values', () => {
 		const color = new HSL(120, 50, 50, 0.5);
 		const clone = color.clone();
 		expect(clone).toBeInstanceOf(HSL);
@@ -32,7 +33,7 @@ describe('HSL Class', () => {
 
 	describe('conversion', () => {
 
-		test('asString should return correct HSL and HSLA strings', () => {
+		it('asString should return correct HSL and HSLA strings', () => {
 			const color1 = new HSL(120, 50, 50);
 			expect(color1.asString()).toBe('hsl(120,50%,50%)');
 
@@ -40,13 +41,13 @@ describe('HSL Class', () => {
 			expect(color2.asString()).toBe('hsla(120,50%,50%,0.5)');
 		});
 
-		test('asHSL and toHSL should return the same instance', () => {
+		it('asHSL and toHSL should return the same instance', () => {
 			const color = new HSL(120, 50, 50);
 			expect(color.asHSL()).toStrictEqual(color);
 			expect(color.toHSL()).toStrictEqual(color);
 		});
 
-		test('asHSV should correctly convert HSL to HSV', () => {
+		it('asHSV should correctly convert HSL to HSV', () => {
 			function check(input: [number, number, number], output: [number, number, number]) {
 				const hsl = new HSL(...input);
 				const hsv = hsl.asHSV();
@@ -66,7 +67,7 @@ describe('HSL Class', () => {
 			check([18, 100, 100], [18, 0, 100]);
 		});
 
-		test('asRGB should correctly convert HSL to RGB', () => {
+		it('asRGB should correctly convert HSL to RGB', () => {
 			function check(input: [number, number, number], output: [number, number, number]) {
 				const hsl = new HSL(...input)
 				const rgb = hsl.asRGB();
@@ -90,7 +91,7 @@ describe('HSL Class', () => {
 
 	describe('should parse valid HSL and HSLA strings', () => {
 		function check(str: string, result: number[]) {
-			test(`parse "${str}"`, () => {
+			it(`parse "${str}"`, () => {
 				const color = HSL.parse(str);
 				expect(color).toBeInstanceOf(HSL);
 				expect(color.asArray()).toStrictEqual(result);
@@ -101,7 +102,7 @@ describe('HSL Class', () => {
 		check('hsla(240,100%,50%,0.75)', [240, 100, 50, 0.75]);
 		check('hsl(400,50%,50%)', [40, 50, 50, 1]);
 
-		test('parse should throw an error for invalid strings', () => {
+		it('parse should throw an error for invalid strings', () => {
 			expect(() => HSL.parse('invalid')).toThrow('Invalid HSL color string');
 		});
 	});
@@ -110,11 +111,11 @@ describe('HSL Class', () => {
 		let color: HSL;
 		beforeEach(() => color = new HSL(120, 50, 50, 0.8));
 
-		test('inverts luminosity correctly', () => {
+		it('inverts luminosity correctly', () => {
 			expect(color.invertLuminosity().asArray()).toStrictEqual([120, 50, 50, 0.8]); // Luminosity inverted to 50%
 		});
 
-		test('handles edge cases for luminosity inversion', () => {
+		it('handles edge cases for luminosity inversion', () => {
 			const black = new HSL(0, 0, 0, 1);
 			expect(black.invertLuminosity().asArray()).toStrictEqual([0, 0, 100, 1]); // Black becomes white
 
@@ -127,15 +128,15 @@ describe('HSL Class', () => {
 		let color: HSL;
 		beforeEach(() => color = new HSL(120, 50, 50, 0.8));
 
-		test('rotates hue correctly within the range of 0-360', () => {
+		it('rotates hue correctly within the range of 0-360', () => {
 			expect(color.rotateHue(180).asArray()).toStrictEqual([300, 50, 50, 0.8]); // Hue rotated by 180 degrees
 		});
 
-		test('handles negative rotation correctly', () => {
+		it('handles negative rotation correctly', () => {
 			expect(color.rotateHue(-270).asArray()).toStrictEqual([210, 50, 50, 0.8]); // Hue rotated negatively
 		});
 
-		test('handles rotations that exceed 360 degrees', () => {
+		it('handles rotations that exceed 360 degrees', () => {
 			expect(color.rotateHue(540).asArray()).toStrictEqual([300, 50, 50, 0.8]); // Hue wrapped around to 300
 		});
 	});
@@ -147,16 +148,16 @@ describe('HSL Class', () => {
 			grey = new HSL(120, 0, 50, 0.8);
 		});
 
-		test('increases saturation correctly', () => {
+		it('increases saturation correctly', () => {
 			expect(color.saturate(0.5).asArray()).toStrictEqual([120, 75, 50, 0.8]);
 			expect(grey.saturate(0.5).asArray()).toStrictEqual([120, 0, 50, 0.8]);
 		});
 
-		test('decreases saturation correctly', () => {
+		it('decreases saturation correctly', () => {
 			expect(color.saturate(-0.5).asArray()).toStrictEqual([120, 25, 50, 0.8]); // Saturation decreased by 50%
 		});
 
-		test('clamps saturation to the valid range', () => {
+		it('clamps saturation to the valid range', () => {
 			expect(color.saturate(1.5).asArray()).toStrictEqual([120, 100, 50, 0.8]); // Saturation clamped to 100%
 
 			expect(color.saturate(-2).asArray()).toStrictEqual([120, 0, 50, 0.8]); // Saturation clamped to 0%
@@ -167,11 +168,11 @@ describe('HSL Class', () => {
 		let color: HSL;
 		beforeEach(() => color = new HSL(120, 50, 50, 0.8));
 
-		test('reduces alpha correctly', () => {
+		it('reduces alpha correctly', () => {
 			expect(color.fade(0.5).asArray()).toStrictEqual([120, 50, 50, 0.4]); // Alpha reduced by 50%
 		});
 
-		test('handles edge cases for fading', () => {
+		it('handles edge cases for fading', () => {
 			const opaque = new HSL(0, 50, 50, 1);
 			expect(opaque.fade(1).asArray()).toStrictEqual([0, 50, 50, 0]); // Fully faded to transparent
 

package/src/color/hsv.test.ts

@@ -1,10 +1,11 @@
+import { describe, expect, it } from 'vitest';
 import { HSV } from './hsv.js';
 import { HSL } from './hsl.js';
 import { RGB } from './rgb.js';
 
 describe('HSV Class', () => {
 
-	test('constructor initializes values correctly with clamping', () => {
+	it('constructor initializes values correctly with clamping', () => {
 		const color = new HSV(400, 120, 120, 2);
 		expect(color.asArray()).toStrictEqual([40, 100, 100, 1]);
 
@@ -12,12 +13,12 @@ describe('HSV Class', () => {
 		expect(colorNegative.asArray()).toStrictEqual([300, 0, 0, 0]);
 	});
 
-	test('asArray returns correct array representation', () => {
+	it('asArray returns correct array representation', () => {
 		const color = new HSV(120, 50, 50, 0.5);
 		expect(color.asArray()).toStrictEqual([120, 50, 50, 0.5]);
 	});
 
-	test('clone returns a new instance with identical values', () => {
+	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);
@@ -26,35 +27,35 @@ describe('HSV Class', () => {
 	});
 
 	describe('asString', () => {
-		test('converts fully saturated colors correctly', () => {
+		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%)');
 		});
 
-		test('handles partially saturated colors', () => {
+		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%)');
 		});
 
-		test('handles achromatic (grey) colors', () => {
+		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%)');
 		});
 
-		test('handles hue wrapping and extreme values', () => {
+		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%)');
 		});
 
-		test('handles alpha transparency', () => {
+		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%)');
 		});
 
-		test('produces consistent results for repeated calls', () => {
+		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%)');
@@ -63,7 +64,7 @@ describe('HSV Class', () => {
 
 	describe('color conversion', () => {
 
-		test('asHSL converts HSV to HSL correctly', () => {
+		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();
@@ -85,7 +86,7 @@ describe('HSV Class', () => {
 			check([18, 100, 100], [18, 100, 50]);
 		});
 
-		test('asRGB converts HSV to RGB correctly', () => {
+		it('asRGB converts HSV to RGB correctly', () => {
 			const color = new HSV(120, 100, 100);
 			const rgb = color.asRGB();
 			expect(rgb).toBeInstanceOf(RGB);
@@ -93,13 +94,13 @@ describe('HSV Class', () => {
 				.toStrictEqual([0, 255, 0, 1]);
 		});
 
-		test('asHSV and toHSV return the same instance or clone', () => {
+		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);
 		});
 
-		test('asRGB conversion S and V', () => {
+		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();
@@ -118,7 +119,7 @@ describe('HSV Class', () => {
 			check([18, 100, 100], [255, 77, 0]);
 		});
 
-		test('asRGB conversion H', () => {
+		it('asRGB conversion H', () => {
 			function check(hue: number, output: string) {
 				const color = new HSV(hue, 100, 100);
 				expect(color.asRGB().asHex()).toBe(output);
@@ -146,24 +147,24 @@ describe('HSV Class', () => {
 	});
 
 	describe('parse errors and validations', () => {
-		test('constructor clamps out-of-bound values', () => {
+		it('constructor clamps out-of-bound values', () => {
 			const color = new HSV(400, 150, 150, 2);
 			expect(color.asArray()).toStrictEqual([40, 100, 100, 1]);
 		});
 
-		test('negative values are handled correctly', () => {
+		it('negative values are handled correctly', () => {
 			const color = new HSV(-360, -50, -50, -1);
 			expect(color.asArray()).toStrictEqual([0, 0, 0, 0]);
 		});
 	});
 
 	describe('fade', () => {
-		test('reduces alpha correctly', () => {
+		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%
 		});
 
-		test('handles edge cases for fading', () => {
+		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
 

package/src/color/hsv.ts

@@ -1,5 +1,6 @@
 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';
 
@@ -165,4 +166,8 @@ export class HSV extends Color {
 	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,8 +1,10 @@
+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][] = [
@@ -18,7 +20,7 @@ describe('Color Conversions', () => {
 		[800, 100, 100, 0.9],
 		[900, 12, 13, 1.0],
 	]
-	test('test HSV -> HSL -> RGB', () => {
+	it('test HSV -> HSL -> RGB', () => {
 		for (const v of scenarios) {
 			const hsv = new HSV(...v);
 			expect(hsv.a).toEqual(v[3]);
@@ -29,7 +31,7 @@ describe('Color Conversions', () => {
 		}
 	});
 
-	test('test HSL -> HSV -> RGB', () => {
+	it('test HSL -> HSV -> RGB', () => {
 		for (const v of scenarios) {
 			const hsl = new HSL(...v);
 			expect(hsl.a).toEqual(v[3]);
@@ -42,7 +44,7 @@ describe('Color Conversions', () => {
 })
 
 describe('Color.parse', () => {
-	test('parses hexadecimal color strings correctly', () => {
+	it('parses hexadecimal color strings correctly', () => {
 		const color = Color.parse('#ff8040');
 		expect(color).toBeInstanceOf(RGB);
 		expect(color.asArray()).toStrictEqual([255, 128, 64, 1]);
@@ -52,7 +54,7 @@ describe('Color.parse', () => {
 		expect(colorWithAlpha.asHex()).toStrictEqual('#FF80407F');
 	});
 
-	test('parses RGB strings correctly', () => {
+	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]);
@@ -62,7 +64,7 @@ describe('Color.parse', () => {
 		expect(colorWithAlpha.asArray()).toStrictEqual([255, 128, 64, 0.5]);
 	});
 
-	test('parses HSL strings correctly', () => {
+	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]);
@@ -72,27 +74,27 @@ describe('Color.parse', () => {
 		expect(colorWithAlpha.asArray()).toStrictEqual([120, 50, 50, 0.5]);
 	});
 
-	test('throws an error for unsupported formats', () => {
+	it('throws an error for unsupported formats', () => {
 		expect(() => Color.parse('invalid color string')).toThrow('Unknown color format: invalid color string');
 	});
 });
 
 describe('Color Class Properties', () => {
-	test('Color.HSL is accessible', () => {
+	it('Color.HSL is accessible', () => {
 		expect(Color.HSL).toBe(HSL);
 	});
 
-	test('Color.HSV is accessible', () => {
+	it('Color.HSV is accessible', () => {
 		expect(Color.HSV).toBe(HSV);
 	});
 
-	test('Color.RGB is accessible', () => {
+	it('Color.RGB is accessible', () => {
 		expect(Color.RGB).toBe(RGB);
 	});
 });
 
 describe('Exported Module', () => {
-	test('named export is Color', async () => {
+	it('named export is Color', async () => {
 		const module = await import('./index.js');
 		expect(module.Color).toBe(Color);
 	});

package/src/color/random.test.ts

@@ -1,14 +1,15 @@
+import { describe, expect, it } from 'vitest';
 import { HSV } from './hsv.js';
 import type { RandomColorOptions } from './random.js';
 import randomColor from './random.js';
 
 describe('RandomColor', () => {
-	test('constructor initializes without errors', () => {
+	it('constructor initializes without errors', () => {
 		expect(randomColor).toBeDefined();
 	});
 
 	describe('Color.random', () => {
-		test('generates random HSV colors', () => {
+		it('generates random HSV colors', () => {
 			const random = randomColor();
 			expect(random).toBeInstanceOf(HSV);
 			const array = random.asArray();
@@ -20,7 +21,7 @@ describe('RandomColor', () => {
 			expect(array[2]).toBeLessThanOrEqual(100);
 		});
 	
-		test('supports options for generating random colors', () => {
+		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
@@ -28,7 +29,7 @@ describe('RandomColor', () => {
 	});
 
 	describe('randomColor method', () => {
-		test('returns correct color string for some test cases', () => {
+		it('returns correct color string for some test cases', () => {
 			function t(options: RandomColorOptions): string {
 				return randomColor(options).asHSL().asString();
 			}
@@ -41,13 +42,13 @@ describe('RandomColor', () => {
 			expect(t({ seed: 'testSeed' })).toBe('hsl(185,90%,23%)');
 		});
 
-		test('consistent color generation with a seed', () => {
+		it('consistent color generation with a seed', () => {
 			const color1 = randomColor({ seed: 'consistentSeed' });
 			const color2 = randomColor({ seed: 'consistentSeed' });
 			expect(color1.asHex()).toBe(color2.asHex());
 		});
 
-		test('different color generation without a seed', () => {
+		it('different color generation without a seed', () => {
 			const color1 = randomColor({ seed: 'seed1' });
 			const color2 = randomColor({ seed: 'seed2' });
 			expect(color1.asHex()).not.toBe(color2.asHex());