@tsparticles/plugin-hsv-color 3.0.3 → 3.2.0

package/umd/HsvColorManager.js

@@ -11,27 +11,33 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.HsvColorManager = exports.hsvaToRgba = exports.hsvToRgb = exports.hsvaToHsla = exports.hsvToHsl = exports.hslaToHsva = exports.hslToHsv = exports.getStyleFromHsv = exports.rgbaToHsva = exports.rgbToHsv = void 0;
     const engine_1 = require("@tsparticles/engine");
+    const rgbFactor = 255, double = 2, half = 0.5;
     function rgbToHsv(rgb) {
         const rgbPercent = {
-            r: rgb.r / 255,
-            g: rgb.g / 255,
-            b: rgb.b / 255,
+            r: rgb.r / rgbFactor,
+            g: rgb.g / rgbFactor,
+            b: rgb.b / rgbFactor,
         }, 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 = 60 * ((rgbPercent.g - rgbPercent.b) / c);
+            h = phaseValue * (phaseOffset.r + (rgbPercent.g - rgbPercent.b) / c);
         }
         else if (v === rgbPercent.g) {
-            h = 60 * (2 + (rgbPercent.b - rgbPercent.r) / c);
+            h = phaseValue * (phaseOffset.g + (rgbPercent.b - rgbPercent.r) / c);
         }
         else if (v === rgbPercent.b) {
-            h = 60 * (4 + (rgbPercent.r - rgbPercent.g) / c);
+            h = phaseValue * (phaseOffset.b + (rgbPercent.r - rgbPercent.g) / c);
         }
-        const s = !v ? 0 : c / v;
+        const defaultSaturation = 0, s = !v ? defaultSaturation : c / v;
         return {
             h,
-            s: s * 100,
-            v: v * 100,
+            s: s * engine_1.percentDenominator,
+            v: v * engine_1.percentDenominator,
         };
     }
     exports.rgbToHsv = rgbToHsv;
@@ -47,11 +53,11 @@
     }
     exports.getStyleFromHsv = getStyleFromHsv;
     function hslToHsv(hsl) {
-        const l = hsl.l / 100, sl = hsl.s / 100, v = l + sl * Math.min(l, 1 - l), sv = !v ? 0 : 2 * (1 - l / v);
+        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 : double * (offset - l / v);
         return {
             h: hsl.h,
-            s: sv * 100,
-            v: v * 100,
+            s: sv * engine_1.percentDenominator,
+            v: v * engine_1.percentDenominator,
         };
     }
     exports.hslToHsv = hslToHsv;
@@ -63,11 +69,11 @@
     }
     exports.hslaToHsva = hslaToHsva;
     function hsvToHsl(hsv) {
-        const v = hsv.v / 100, sv = hsv.s / 100, l = v * (1 - sv / 2), sl = l === 0 || l === 1 ? 0 : (v - l) / Math.min(l, 1 - l);
+        const v = hsv.v / engine_1.percentDenominator, sv = hsv.s / engine_1.percentDenominator, offset = 1, noValue = 0, l = v * (offset - sv * half), sl = !l || l === offset ? noValue : (v - l) / Math.min(l, offset - l);
         return {
             h: hsv.h,
-            l: l * 100,
-            s: sl * 100,
+            l: l * engine_1.percentDenominator,
+            s: sl * engine_1.percentDenominator,
         };
     }
     exports.hsvToHsl = hsvToHsl;
@@ -79,48 +85,49 @@
     }
     exports.hsvaToHsla = hsvaToHsla;
     function hsvToRgb(hsv) {
-        const result = { b: 0, g: 0, r: 0 }, hsvPercent = {
-            h: hsv.h / 60,
-            s: hsv.s / 100,
-            v: hsv.v / 100,
-        }, c = hsvPercent.v * hsvPercent.s, x = c * (1 - Math.abs((hsvPercent.h % 2) - 1));
+        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;
-        if (hsvPercent.h >= 0 && hsvPercent.h <= 1) {
+        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 > 1 && hsvPercent.h <= 2) {
+        else if (hsvPercent.h > xczRange.min && hsvPercent.h <= xczRange.max) {
             tempRgb = {
                 r: x,
                 g: c,
                 b: 0,
             };
         }
-        else if (hsvPercent.h > 2 && hsvPercent.h <= 3) {
+        else if (hsvPercent.h > zcxRange.min && hsvPercent.h <= zcxRange.max) {
             tempRgb = {
                 r: 0,
                 g: c,
                 b: x,
             };
         }
-        else if (hsvPercent.h > 3 && hsvPercent.h <= 4) {
+        else if (hsvPercent.h > zxcRange.min && hsvPercent.h <= zxcRange.max) {
             tempRgb = {
                 r: 0,
                 g: x,
                 b: c,
             };
         }
-        else if (hsvPercent.h > 4 && hsvPercent.h <= 5) {
+        else if (hsvPercent.h > xzcRange.min && hsvPercent.h <= xzcRange.max) {
             tempRgb = {
                 r: x,
                 g: 0,
                 b: c,
             };
         }
-        else if (hsvPercent.h > 5 && hsvPercent.h <= 6) {
+        else if (hsvPercent.h > czxRange.min && hsvPercent.h <= czxRange.max) {
             tempRgb = {
                 r: c,
                 g: 0,
@@ -129,9 +136,9 @@
         }
         if (tempRgb) {
             const m = hsvPercent.v - c;
-            result.r = Math.floor((tempRgb.r + m) * 255);
-            result.g = Math.floor((tempRgb.g + m) * 255);
-            result.b = Math.floor((tempRgb.b + m) * 255);
+            result.r = Math.floor((tempRgb.r + m) * rgbFactor);
+            result.g = Math.floor((tempRgb.g + m) * rgbFactor);
+            result.b = Math.floor((tempRgb.b + m) * rgbFactor);
         }
         return result;
     }
@@ -168,13 +175,18 @@
             if (!input.startsWith("hsv")) {
                 return;
             }
-            const regex = /hsva?\(\s*(\d+)°\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input);
+            const regex = /hsva?\(\s*(\d+)°\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input), fullLength = 4, indexes = {
+                h: 1,
+                s: 2,
+                v: 3,
+                a: 5,
+            }, defaultAlpha = 1, radix = 10;
             return result
                 ? hsvaToRgba({
-                    a: result.length > 4 ? (0, engine_1.parseAlpha)(result[5]) : 1,
-                    h: parseInt(result[1], 10),
-                    s: parseInt(result[2], 10),
-                    v: parseInt(result[3], 10),
+                    a: result.length > fullLength ? (0, engine_1.parseAlpha)(result[indexes.a]) : defaultAlpha,
+                    h: parseInt(result[indexes.h], radix),
+                    s: parseInt(result[indexes.s], radix),
+                    v: parseInt(result[indexes.v], radix),
                 })
                 : undefined;
         }

package/umd/index.js

@@ -1,19 +1,43 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 (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", "./HsvColorManager.js", "@tsparticles/engine"], factory);
+        define(["require", "exports", "@tsparticles/engine"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadHsvColorPlugin = void 0;
-    const HsvColorManager_js_1 = require("./HsvColorManager.js");
     const engine_1 = require("@tsparticles/engine");
     async function loadHsvColorPlugin() {
-        (0, engine_1.addColorManager)(new HsvColorManager_js_1.HsvColorManager());
+        const { HsvColorManager } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./HsvColorManager.js"))) : new Promise((resolve_1, reject_1) => { require(["./HsvColorManager.js"], resolve_1, reject_1); }).then(__importStar));
+        (0, engine_1.addColorManager)(new HsvColorManager());
     }
     exports.loadHsvColorPlugin = loadHsvColorPlugin;
 });