chore: Update SRGB type definitions to include prefix for color space conflicts

Author: iamlite

.github/workflows/publish.yml

@@ -53,7 +53,7 @@ jobs:
         if: steps.npm-version.outputs.SHOULD_PUBLISH == 'true'
         run: |
           NEW_VERSION=${{ steps.package-version.outputs.current-version }}
-          sed -n "/## \[$NEW_VERSION\]/,/## \[/p" CHANGELOG.md | sed '$d' > RELEASE_CHANGELOG.md
+          sed -n "/## \[$NEW_VERSION\]/,/## \[/p" CHANGELOG.md | sed '$d' > RELEASE_NOTES.md
 
       - name: Create GitHub Release
         if: steps.npm-version.outputs.SHOULD_PUBLISH == 'true'
@@ -63,6 +63,6 @@ jobs:
         with:
           name: Release ${{ steps.package-version.outputs.current-version }}
           tag_name: v${{ steps.package-version.outputs.current-version }}
-          files: RELEASE_CHANGELOG.md
+          body_path: RELEASE_NOTES.md
           draft: false
           prerelease: false

CHANGELOG.md

@@ -8,7 +8,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
-## [1.3.0] - 2024-07-12
+## [1.3.1] - 2024-07-17
+
+### Changed
+
+- Updated SRGB type definitions to include prefix to avoid conflicts with other color spaces
+
+## [1.3.0] - 2024-07-17
 
 ## BIG UPDATE 🎉
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "color-core",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A comprehensive color manipulation library for Next.js and React applications",
   "author": "Tariel Davidashvili <[email protected]> (http://tariel.me/)",
   "license": "MIT",
@@ -121,4 +121,4 @@
     }
   ],
   "packageManager": "[email protected]"
-}
+}

src/color.ts

@@ -1,5 +1,6 @@
 import {
     adobeRGBToRGB, cieLuvToRgb, ciexyyToRgb, cmykToRgb, hexToRgb, hpluvToRgb, hsiToRgb, hslToRgb, hsluvToRgb, hsvToRgb, hwbToRgb, labToRgb, lchToRgb, oklabToRgb, oklchToRgb, rgbToAdobeRGB, rgbToCIELuv, rgbToCIExyY, rgbToCmyk, rgbToHex, rgbToHPLuv, rgbToHsi, rgbToHsl, rgbToHSLuv, rgbToHsv, rgbToHwb, rgbToLab, rgbToLabD50, rgbToLch, rgbToOklab, rgbToOklch, rgbToSrgb, rgbToXyz, rgbToXyzD50, rgbToYuv,
+    srgbToRgb,
     xyzToRgb, yuvToRgb
 } from './conversions';
 import {
@@ -32,12 +33,14 @@ export class Color {
      * Creates a new Color instance.
      * @param color - The color value to initialize with. Can be a string (hex) or an object representing various color spaces.
      */
-    constructor(color: string | RGB | HSL | HSV | CMYK | LAB | LCH | LUV | XYZ | YUV | Oklab | Oklch | HSLuv | HPLuv | CIExyY | HSI | HWB | AdobeRGB) {
+    constructor(color: string | RGB | SRGB | HSL | HSV | CMYK | LAB | LCH | LUV | XYZ | YUV | Oklab | Oklch | HSLuv | HPLuv | CIExyY | HSI | HWB | AdobeRGB) {
         if (typeof color === 'string') {
             this._rgb = hexToRgb(color);
 
         } else if ('r' in color && 'g' in color && 'b' in color) {
             this._rgb = { ...color, a: color.a ?? 1 };
+        } else if ('sr' in color && 'sg' in color && 'sb' in color) {
+            this._rgb = srgbToRgb(color as SRGB);
         } else if ('x' in color && 'y' in color && 'z' in color) {
             this._rgb = xyzToRgb(color as XYZ);
         } else if ('l' in color && 'a' in color && 'b' in color) {

src/conversions/components/__tests__/srgb.test.ts

@@ -4,11 +4,11 @@ import { rgbToSrgb, srgbToRgb } from '../srgb';
 describe('sRGB <-> RGB Conversions', () => {
     describe('rgbToSrgb', () => {
         it('should convert RGB to sRGB correctly', () => {
-            expect(rgbToSrgb({ r: 255, g: 0, b: 0 })).toEqual({ r: 1, g: 0, b: 0 });
-            expect(rgbToSrgb({ r: 0, g: 255, b: 0 })).toEqual({ r: 0, g: 1, b: 0 });
-            expect(rgbToSrgb({ r: 0, g: 0, b: 255 })).toEqual({ r: 0, g: 0, b: 1 });
-            expect(rgbToSrgb({ r: 255, g: 255, b: 255 })).toEqual({ r: 1, g: 1, b: 1 });
-            expect(rgbToSrgb({ r: 0, g: 0, b: 0 })).toEqual({ r: 0, g: 0, b: 0 });
+            expect(rgbToSrgb({ r: 255, g: 0, b: 0 })).toEqual({ sr: 1, sg: 0, sb: 0 });
+            expect(rgbToSrgb({ r: 0, g: 255, b: 0 })).toEqual({ sr: 0, sg: 1, sb: 0 });
+            expect(rgbToSrgb({ r: 0, g: 0, b: 255 })).toEqual({ sr: 0, sg: 0, sb: 1 });
+            expect(rgbToSrgb({ r: 255, g: 255, b: 255 })).toEqual({ sr: 1, sg: 1, sb: 1 });
+            expect(rgbToSrgb({ r: 0, g: 0, b: 0 })).toEqual({ sr: 0, sg: 0, sb: 0 });
         });
 
         it('should throw error for invalid input', () => {
@@ -20,17 +20,17 @@ describe('sRGB <-> RGB Conversions', () => {
 
     describe('srgbToRgb', () => {
         it('should convert sRGB to RGB correctly', () => {
-            expect(srgbToRgb({ r: 1, g: 0, b: 0 })).toEqual({ r: 255, g: 0, b: 0 });
-            expect(srgbToRgb({ r: 0, g: 1, b: 0 })).toEqual({ r: 0, g: 255, b: 0 });
-            expect(srgbToRgb({ r: 0, g: 0, b: 1 })).toEqual({ r: 0, g: 0, b: 255 });
-            expect(srgbToRgb({ r: 1, g: 1, b: 1 })).toEqual({ r: 255, g: 255, b: 255 });
-            expect(srgbToRgb({ r: 0, g: 0, b: 0 })).toEqual({ r: 0, g: 0, b: 0 });
+            expect(srgbToRgb({ sr: 1, sg: 0, sb: 0 })).toEqual({ r: 255, g: 0, b: 0 });
+            expect(srgbToRgb({ sr: 0, sg: 1, sb: 0 })).toEqual({ r: 0, g: 255, b: 0 });
+            expect(srgbToRgb({ sr: 0, sg: 0, sb: 1 })).toEqual({ r: 0, g: 0, b: 255 });
+            expect(srgbToRgb({ sr: 1, sg: 1, sb: 1 })).toEqual({ r: 255, g: 255, b: 255 });
+            expect(srgbToRgb({ sr: 0, sg: 0, sb: 0 })).toEqual({ r: 0, g: 0, b: 0 });
         });
 
         it('should throw error for invalid input', () => {
             expect(() => srgbToRgb(123 as any)).toThrow('Input must be an object');
             expect(() => srgbToRgb({ r: 'invalid', g: 0, b: 0 } as any)).toThrow('sRGB values must be numbers');
-            expect(() => srgbToRgb({ r: -1, g: 0, b: 0 })).toThrow('sRGB values must be between 0 and 1');
+            expect(() => srgbToRgb({ sr: -1, sg: 0, sb: 0 })).toThrow('sRGB values must be between 0 and 1');
         });
     });
 

src/conversions/components/srgb.ts

@@ -30,9 +30,9 @@ export function rgbToSrgb(rgb: RGB): SRGB {
     const gammaCorrect = (c: number) => (c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
 
     return {
-        r: gammaCorrect(rNorm),
-        g: gammaCorrect(gNorm),
-        b: gammaCorrect(bNorm),
+        sr: gammaCorrect(rNorm),
+        sg: gammaCorrect(gNorm),
+        sb: gammaCorrect(bNorm),
     };
 }
 
@@ -47,22 +47,22 @@ export function srgbToRgb(srgb: SRGB): RGB {
         throw new Error('Input must be an object');
     }
 
-    const { r, g, b } = srgb;
+    const { sr, sg, sb } = srgb;
 
-    if (typeof r !== 'number' || typeof g !== 'number' || typeof b !== 'number') {
+    if (typeof sr !== 'number' || typeof sg !== 'number' || typeof sb !== 'number') {
         throw new Error('sRGB values must be numbers');
     }
 
-    if (r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1) {
+    if (sr < 0 || sr > 1 || sg < 0 || sg > 1 || sb < 0 || sb > 1) {
         throw new Error('sRGB values must be between 0 and 1');
     }
 
     // Apply inverse gamma correction
     const inverseGammaCorrect = (c: number) => (c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055);
 
     return {
-        r: Math.round(inverseGammaCorrect(r) * 255),
-        g: Math.round(inverseGammaCorrect(g) * 255),
-        b: Math.round(inverseGammaCorrect(b) * 255),
+        r: Math.round(inverseGammaCorrect(sr) * 255),
+        g: Math.round(inverseGammaCorrect(sg) * 255),
+        b: Math.round(inverseGammaCorrect(sb) * 255),
     };
 }

src/types.ts

@@ -187,9 +187,9 @@ export type CIExyY = {
  * Values are typically between 0 and 255.
  */
 export type SRGB = {
-    r: number;
-    g: number;
-    b: number;
+    sr: number;
+    sg: number;
+    sb: number;
 };
 
 /**