omni-color 0.1.0

package/dist/__test__/color-interop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/color-interop.test.js

@@ -0,0 +1,82 @@
+import chroma from 'chroma-js';
+import { Color } from '../index';
+describe('Color interoperability with chroma-js', () => {
+    describe('parses and normalizes inputs the same way', () => {
+        it('matches chroma-js hex and rgb outputs across formats', () => {
+            const baseHex = new Color('#336699');
+            const baseHexChroma = chroma('#336699');
+            expect(baseHex.toHex()).toBe(baseHexChroma.hex().toLowerCase());
+            expect(baseHex.toRGB()).toEqual({
+                r: baseHexChroma.rgb()[0],
+                g: baseHexChroma.rgb()[1],
+                b: baseHexChroma.rgb()[2],
+            });
+            const namedColor = new Color('rebeccapurple');
+            const namedColorChroma = chroma('rebeccapurple');
+            expect(namedColor.toHex()).toBe(namedColorChroma.hex().toLowerCase());
+            expect(namedColor.toRGB()).toEqual({
+                r: namedColorChroma.rgb()[0],
+                g: namedColorChroma.rgb()[1],
+                b: namedColorChroma.rgb()[2],
+            });
+            const hslStringColor = new Color('hsl(210, 50%, 40%)');
+            const hslStringChroma = chroma('hsl(210, 50%, 40%)');
+            expect(hslStringColor.toHex()).toBe(hslStringChroma.hex().toLowerCase());
+            expect(hslStringColor.toRGB()).toEqual({
+                r: hslStringChroma.rgb()[0],
+                g: hslStringChroma.rgb()[1],
+                b: hslStringChroma.rgb()[2],
+            });
+        });
+    });
+    describe('handles alpha channels similarly', () => {
+        it('keeps alpha values aligned for hex8 and rgba inputs', () => {
+            const hexWithAlpha = new Color('#1e90ff80');
+            const hexWithAlphaChroma = chroma('#1e90ff80');
+            expect(hexWithAlpha.toHex8()).toBe(hexWithAlphaChroma.hex('rgba').toLowerCase());
+            expect(hexWithAlpha.toRGBA()).toEqual({
+                r: hexWithAlphaChroma.rgba()[0],
+                g: hexWithAlphaChroma.rgba()[1],
+                b: hexWithAlphaChroma.rgba()[2],
+                a: expect.closeTo(hexWithAlphaChroma.rgba()[3], 2),
+            });
+            const rgbaStringColor = new Color('rgba(12, 200, 180, 0.35)');
+            const rgbaStringChroma = chroma('rgba(12, 200, 180, 0.35)');
+            expect(rgbaStringColor.toHex8()).toBe(rgbaStringChroma.hex('rgba').toLowerCase());
+            expect(rgbaStringColor.toRGBA()).toEqual({
+                r: rgbaStringChroma.rgba()[0],
+                g: rgbaStringChroma.rgba()[1],
+                b: rgbaStringChroma.rgba()[2],
+                a: expect.closeTo(rgbaStringChroma.rgba()[3], 2),
+            });
+        });
+    });
+    describe('agrees on HSL and HSV math', () => {
+        it('matches hue, saturation, and lightness/brightness values', () => {
+            const vividOrange = new Color('#ff7f0e');
+            const vividOrangeChroma = chroma('#ff7f0e');
+            const vividOrangeHsl = vividOrangeChroma.hsl();
+            const vividOrangeHslFromOmniColor = vividOrange.toHSL();
+            expect(vividOrangeHslFromOmniColor.h).toBeCloseTo(vividOrangeHsl[0], 0);
+            expect(vividOrangeHslFromOmniColor.s).toBeCloseTo(vividOrangeHsl[1] * 100, 0);
+            expect(vividOrangeHslFromOmniColor.l).toBeCloseTo(vividOrangeHsl[2] * 100, 0);
+            const vividOrangeHsv = vividOrangeChroma.hsv();
+            const vividOrangeHsvFromOmniColor = vividOrange.toHSV();
+            expect(vividOrangeHsvFromOmniColor.h).toBeCloseTo(vividOrangeHsv[0], 0);
+            expect(vividOrangeHsvFromOmniColor.s).toBeCloseTo(vividOrangeHsv[1] * 100, 0);
+            expect(vividOrangeHsvFromOmniColor.v).toBeCloseTo(vividOrangeHsv[2] * 100, 0);
+            const mutedTeal = new Color('rgb(32, 160, 150)');
+            const mutedTealChroma = chroma('rgb(32, 160, 150)');
+            const mutedTealHsl = mutedTealChroma.hsl();
+            const mutedTealHslFromOmniColor = mutedTeal.toHSL();
+            expect(mutedTealHslFromOmniColor.h).toBeCloseTo(mutedTealHsl[0], 0);
+            expect(mutedTealHslFromOmniColor.s).toBeCloseTo(mutedTealHsl[1] * 100, 0);
+            expect(mutedTealHslFromOmniColor.l).toBeCloseTo(mutedTealHsl[2] * 100, 0);
+            const mutedTealHsv = mutedTealChroma.hsv();
+            const mutedTealHsvFromOmniColor = mutedTeal.toHSV();
+            expect(mutedTealHsvFromOmniColor.h).toBeCloseTo(mutedTealHsv[0], 0);
+            expect(mutedTealHsvFromOmniColor.s).toBeCloseTo(mutedTealHsv[1] * 100, 0);
+            expect(mutedTealHsvFromOmniColor.v).toBeCloseTo(mutedTealHsv[2] * 100, 0);
+        });
+    });
+});

package/dist/__test__/comparison_culori.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/comparison_culori.test.js

@@ -0,0 +1,169 @@
+import { converter, differenceCie76, differenceCie94, differenceCiede2000, formatHex8, parse, wcagContrast, } from 'culori';
+import { Color } from '../color/color';
+const culoriToRgb = converter('rgb');
+const culoriToHsl = converter('hsl');
+const culoriToHsv = converter('hsv');
+const culoriToLab = converter('lab');
+const culoriToLch = converter('lch');
+const culoriToOklch = converter('oklch');
+const TEST_COLORS = [
+    '#ff0000',
+    '#00ff00',
+    '#0000ff',
+    '#000000',
+    '#ffffff',
+    '#808080',
+    '#f0f8ff', // aliceblue
+    '#ff1493', // deeppink
+    '#00ced1', // darkturquoise
+    'rgba(255, 0, 0, 0.5)',
+    'hsla(120, 100%, 50%, 0.3)',
+    '#12345678',
+    { r: 100, g: 150, b: 200 },
+    { h: 200, s: 50, l: 50 },
+    { l: 50, a: 10, b: -10 },
+    { l: 0.5, c: 0.1, h: 180, alpha: 1 }, // OKLCH-like object
+];
+// Helper to handle hue being undefined in culori for grayscale
+const fixHue = (h) => (h === undefined || isNaN(h) ? 0 : h);
+function parseOrThrow(input) {
+    const result = parse(input);
+    if (!result) {
+        throw new Error(`Culori failed to parse: ${input}`);
+    }
+    return result;
+}
+// TODO: unskip and fix these tests
+describe.skip('Cross-check with Culori', () => {
+    describe('Conversions', () => {
+        TEST_COLORS.forEach((input) => {
+            const omni = new Color(input);
+            const sourceHex8 = omni.toHex8();
+            const culoriColor = parseOrThrow(sourceHex8);
+            describe(`Input: ${JSON.stringify(input)} (Hex8: ${sourceHex8})`, () => {
+                it('matches RGB', () => {
+                    const omniRgb = omni.toRGB();
+                    const culoriRgb = culoriToRgb(culoriColor);
+                    expect(omniRgb.r).toBeCloseTo(culoriRgb.r * 255, 0);
+                    expect(omniRgb.g).toBeCloseTo(culoriRgb.g * 255, 0);
+                    expect(omniRgb.b).toBeCloseTo(culoriRgb.b * 255, 0);
+                    const omniAlpha = omni.getAlpha();
+                    const culoriAlpha = culoriRgb.alpha ?? 1;
+                    expect(omniAlpha).toBeCloseTo(culoriAlpha, 2);
+                });
+                it('matches HEX', () => {
+                    const omniHex8 = omni.toHex8();
+                    const culoriHex8 = formatHex8(culoriColor);
+                    expect(omniHex8).toBe(culoriHex8);
+                });
+                it('matches HSL', () => {
+                    const omniHsl = omni.toHSL();
+                    const culoriHsl = culoriToHsl(culoriColor);
+                    const ch = fixHue(culoriHsl.h);
+                    if (omniHsl.s > 1) {
+                        const diff = Math.abs(omniHsl.h - ch);
+                        const diffWrapped = Math.min(diff, 360 - diff);
+                        expect(diffWrapped).toBeLessThan(2);
+                    }
+                    expect(omniHsl.s).toBeCloseTo(culoriHsl.s * 100, 0);
+                    expect(omniHsl.l).toBeCloseTo(culoriHsl.l * 100, 0);
+                });
+                it('matches HSV', () => {
+                    const omniHsv = omni.toHSV();
+                    const culoriHsv = culoriToHsv(culoriColor);
+                    const ch = fixHue(culoriHsv.h);
+                    if (omniHsv.s > 1) {
+                        const diff = Math.abs(omniHsv.h - ch);
+                        const diffWrapped = Math.min(diff, 360 - diff);
+                        expect(diffWrapped).toBeLessThan(2);
+                    }
+                    expect(omniHsv.s).toBeCloseTo(culoriHsv.s * 100, 0);
+                    expect(omniHsv.v).toBeCloseTo(culoriHsv.v * 100, 0);
+                });
+                it('matches Lab', () => {
+                    const omniLab = omni.toLAB();
+                    const culoriLab = culoriToLab(culoriColor);
+                    expect(omniLab.l).toBeCloseTo(culoriLab.l, 1);
+                    expect(omniLab.a).toBeCloseTo(culoriLab.a, 1);
+                    expect(omniLab.b).toBeCloseTo(culoriLab.b, 1);
+                });
+                it('matches LCH', () => {
+                    const omniLch = omni.toLCH();
+                    const culoriLch = culoriToLch(culoriColor);
+                    expect(omniLch.l).toBeCloseTo(culoriLch.l, 1);
+                    expect(omniLch.c).toBeCloseTo(culoriLch.c, 1);
+                    if (omniLch.c > 1) {
+                        const ch = fixHue(culoriLch.h);
+                        const diff = Math.abs(omniLch.h - ch);
+                        const diffWrapped = Math.min(diff, 360 - diff);
+                        expect(diffWrapped).toBeLessThan(2);
+                    }
+                });
+                it('matches OKLCH', () => {
+                    const omniOklch = omni.toOKLCH();
+                    const culoriOklch = culoriToOklch(culoriColor);
+                    expect(omniOklch.l).toBeCloseTo(culoriOklch.l, 3);
+                    expect(omniOklch.c).toBeCloseTo(culoriOklch.c, 3);
+                    if (omniOklch.c > 0.01) {
+                        const ch = fixHue(culoriOklch.h);
+                        const diff = Math.abs(omniOklch.h - ch);
+                        const diffWrapped = Math.min(diff, 360 - diff);
+                        expect(diffWrapped).toBeLessThan(2);
+                    }
+                });
+            });
+        });
+    });
+    describe('DeltaE', () => {
+        // Pairs to compare
+        const pairs = [
+            ['#ff0000', '#ff0000'],
+            ['#ff0000', '#ff0100'],
+            ['#ff0000', '#00ff00'],
+            ['#000000', '#ffffff'],
+            ['#123456', '#654321'],
+        ];
+        pairs.forEach(([c1, c2]) => {
+            const color1 = new Color(c1);
+            const color2 = new Color(c2);
+            const culori1 = parseOrThrow(color1.toHex8());
+            const culori2 = parseOrThrow(color2.toHex8());
+            describe(`${c1} vs ${c2}`, () => {
+                it('matches CIE76', () => {
+                    const omniVal = color1.differenceFrom(color2, { method: 'CIE76' });
+                    const culoriVal = differenceCie76()(culori1, culori2);
+                    expect(omniVal).toBeCloseTo(culoriVal, 1);
+                });
+                it('matches CIE94', () => {
+                    const omniVal = color1.differenceFrom(color2, { method: 'CIE94' });
+                    const culoriVal = differenceCie94()(culori1, culori2);
+                    expect(omniVal).toBeCloseTo(culoriVal, 1);
+                });
+                it('matches CIEDE2000', () => {
+                    const omniVal = color1.differenceFrom(color2, { method: 'CIEDE2000' });
+                    const culoriVal = differenceCiede2000()(culori1, culori2);
+                    expect(omniVal).toBeCloseTo(culoriVal, 3);
+                });
+            });
+        });
+    });
+    describe('Contrast', () => {
+        const pairs = [
+            ['#000000', '#ffffff'],
+            ['#ff0000', '#00ff00'],
+            ['#777777', '#888888'],
+            ['#123456', '#abcdef'],
+        ];
+        pairs.forEach(([bg, fg]) => {
+            const bgColor = new Color(bg);
+            const fgColor = new Color(fg);
+            const culoriBg = parseOrThrow(bgColor.toHex8());
+            const culoriFg = parseOrThrow(fgColor.toHex8());
+            it(`matches WCAG contrast for ${bg} on ${fg}`, () => {
+                const omniContrast = bgColor.getContrastRatio(fgColor);
+                const culoriContrast = wcagContrast(culoriBg, culoriFg);
+                expect(omniContrast).toBeCloseTo(culoriContrast, 2);
+            });
+        });
+    });
+});

package/dist/__test__/interop-chroma.test.d.ts

@@ -0,0 +1 @@
+export {};