@tsparticles/plugin-hsv-color 3.9.0 → 4.0.0-alpha.0

package/umd/utils.js

@@ -0,0 +1,151 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.rgbToHsv = rgbToHsv;
+    exports.rgbaToHsva = rgbaToHsva;
+    exports.getStyleFromHsv = getStyleFromHsv;
+    exports.hslToHsv = hslToHsv;
+    exports.hslaToHsva = hslaToHsva;
+    exports.hsvToHsl = hsvToHsl;
+    exports.hsvaToHsla = hsvaToHsla;
+    exports.hsvToRgb = hsvToRgb;
+    exports.hsvaToRgba = hsvaToRgba;
+    const engine_1 = require("@tsparticles/engine");
+    function rgbToHsv(rgb) {
+        const rgbPercent = {
+            r: rgb.r / engine_1.rgbMax,
+            g: rgb.g / engine_1.rgbMax,
+            b: rgb.b / engine_1.rgbMax,
+        }, xMax = Math.max(rgbPercent.r, rgbPercent.g, rgbPercent.b), xMin = Math.min(rgbPercent.r, rgbPercent.g, rgbPercent.b), v = xMax, c = xMax - xMin;
+        let h = 0;
+        const phaseOffset = {
+            r: 0,
+            g: 2,
+            b: 4,
+        }, phaseValue = 60;
+        if (v === rgbPercent.r) {
+            h = phaseValue * (phaseOffset.r + (rgbPercent.g - rgbPercent.b) / c);
+        }
+        else if (v === rgbPercent.g) {
+            h = phaseValue * (phaseOffset.g + (rgbPercent.b - rgbPercent.r) / c);
+        }
+        else if (v === rgbPercent.b) {
+            h = phaseValue * (phaseOffset.b + (rgbPercent.r - rgbPercent.g) / c);
+        }
+        const defaultSaturation = 0, s = !v ? defaultSaturation : c / v;
+        return {
+            h,
+            s: s * engine_1.percentDenominator,
+            v: v * engine_1.percentDenominator,
+        };
+    }
+    function rgbaToHsva(rgba) {
+        return {
+            a: rgba.a,
+            ...rgbToHsv(rgba),
+        };
+    }
+    function getStyleFromHsv(color, hdr, opacity) {
+        return (0, engine_1.getStyleFromHsl)(hsvToHsl(color), hdr, opacity);
+    }
+    function hslToHsv(hsl) {
+        const l = hsl.l / engine_1.percentDenominator, sl = hsl.s / engine_1.percentDenominator, offset = 1, noValue = 0, v = l + sl * Math.min(l, offset - l), sv = !v ? noValue : engine_1.double * (offset - l / v);
+        return {
+            h: hsl.h,
+            s: sv * engine_1.percentDenominator,
+            v: v * engine_1.percentDenominator,
+        };
+    }
+    function hslaToHsva(hsla) {
+        return {
+            a: hsla.a,
+            ...hslToHsv(hsla),
+        };
+    }
+    function hsvToHsl(hsv) {
+        const v = hsv.v / engine_1.percentDenominator, sv = hsv.s / engine_1.percentDenominator, offset = 1, noValue = 0, l = v * (offset - sv * engine_1.half), sl = !l || l === offset ? noValue : (v - l) / Math.min(l, offset - l);
+        return {
+            h: hsv.h,
+            l: l * engine_1.percentDenominator,
+            s: sl * engine_1.percentDenominator,
+        };
+    }
+    function hsvaToHsla(hsva) {
+        return {
+            a: hsva.a,
+            ...hsvToHsl(hsva),
+        };
+    }
+    function hsvToRgb(hsv) {
+        const result = { b: 0, g: 0, r: 0 }, phase = 60, hsvPercent = {
+            h: hsv.h / phase,
+            s: hsv.s / engine_1.percentDenominator,
+            v: hsv.v / engine_1.percentDenominator,
+        }, offset = 1, hPercentFactor = 2, c = hsvPercent.v * hsvPercent.s, x = c * (offset - Math.abs((hsvPercent.h % hPercentFactor) - offset));
+        let tempRgb;
+        const cxzRange = { min: 0, max: 1 }, xczRange = { min: 1, max: 2 }, zcxRange = { min: 2, max: 3 }, zxcRange = { min: 3, max: 4 }, xzcRange = { min: 4, max: 5 }, czxRange = { min: 5, max: 6 };
+        if (hsvPercent.h >= cxzRange.min && hsvPercent.h <= cxzRange.max) {
+            tempRgb = {
+                r: c,
+                g: x,
+                b: 0,
+            };
+        }
+        else if (hsvPercent.h > xczRange.min && hsvPercent.h <= xczRange.max) {
+            tempRgb = {
+                r: x,
+                g: c,
+                b: 0,
+            };
+        }
+        else if (hsvPercent.h > zcxRange.min && hsvPercent.h <= zcxRange.max) {
+            tempRgb = {
+                r: 0,
+                g: c,
+                b: x,
+            };
+        }
+        else if (hsvPercent.h > zxcRange.min && hsvPercent.h <= zxcRange.max) {
+            tempRgb = {
+                r: 0,
+                g: x,
+                b: c,
+            };
+        }
+        else if (hsvPercent.h > xzcRange.min && hsvPercent.h <= xzcRange.max) {
+            tempRgb = {
+                r: x,
+                g: 0,
+                b: c,
+            };
+        }
+        else if (hsvPercent.h > czxRange.min && hsvPercent.h <= czxRange.max) {
+            tempRgb = {
+                r: c,
+                g: 0,
+                b: x,
+            };
+        }
+        if (tempRgb) {
+            const m = hsvPercent.v - c;
+            result.r = Math.floor((tempRgb.r + m) * engine_1.rgbMax);
+            result.g = Math.floor((tempRgb.g + m) * engine_1.rgbMax);
+            result.b = Math.floor((tempRgb.b + m) * engine_1.rgbMax);
+        }
+        return result;
+    }
+    function hsvaToRgba(hsva) {
+        return {
+            a: hsva.a,
+            ...hsvToRgb(hsva),
+        };
+    }
+});