@visulima/colorize 1.4.25 → 1.4.27

package/dist/packem_shared/GradientBuilder-Ba4Teq6P.mjs

@@ -0,0 +1,487 @@
+import { convertHexToRgb } from './convertHexToRgb-CWdAm2kE.mjs';
+
+const colorNames = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 134, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 250, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 221],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [112, 128, 144],
+  slategrey: [112, 128, 144],
+  snow: [255, 250, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 50]
+};
+
+const computeSubSteps = (stops, steps) => {
+  const l = stops.length;
+  steps = Number.parseInt(steps.toString(), 10);
+  if (Number.isNaN(steps) || steps < 2) {
+    throw new Error("Invalid number of steps (< 2)");
+  }
+  if (steps < l) {
+    throw new Error("Number of steps cannot be inferior to number of stops");
+  }
+  const substeps = [];
+  for (let index = 1; index < l; index++) {
+    const step = (steps - 1) * (stops[index].position - stops[index - 1].position);
+    substeps.push(Math.max(1, Math.round(step)));
+  }
+  let totalSubsteps = 1;
+  for (let n = l - 1; n--; ) {
+    totalSubsteps += substeps[n];
+  }
+  while (totalSubsteps !== steps) {
+    if (totalSubsteps < steps) {
+      const min = Math.min(...substeps);
+      substeps[substeps.indexOf(min)]++;
+      totalSubsteps++;
+    } else {
+      const max = Math.max(...substeps);
+      substeps[substeps.indexOf(max)]--;
+      totalSubsteps--;
+    }
+  }
+  return substeps;
+};
+
+const hsvToRgb = (h, s, v) => {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  const index = Math.floor(h / 60);
+  const f = h / 60 - index;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  if (index % 6 === 0) {
+    r = v;
+    g = t;
+    b = p;
+  } else if (index % 6 === 1) {
+    r = q;
+    g = v;
+    b = p;
+  } else if (index % 6 === 2) {
+    r = p;
+    g = v;
+    b = t;
+  } else if (index % 6 === 3) {
+    r = p;
+    g = q;
+    b = v;
+  } else if (index % 6 === 4) {
+    r = t;
+    g = p;
+    b = v;
+  } else if (index % 6 === 5) {
+    r = v;
+    g = p;
+    b = q;
+  }
+  return { b: Math.round(b * 255), g: Math.round(g * 255), r: Math.round(r * 255) };
+};
+
+const rgbToHsv = ({ b, g, r }) => {
+  let rdif;
+  let gdif;
+  let bdif;
+  let h = 0;
+  let s = 0;
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const v = Math.max(r, g, b);
+  const diff = v - Math.min(r, g, b);
+  const diffc = (c) => (v - c) / 6 / diff + 1 / 2;
+  if (diff !== 0) {
+    s = diff / v;
+    rdif = diffc(r);
+    gdif = diffc(g);
+    bdif = diffc(b);
+    if (v === r) {
+      h = bdif - gdif;
+    } else if (v === g) {
+      h = 1 / 3 + rdif - bdif;
+    } else if (v === b) {
+      h = 2 / 3 + gdif - rdif;
+    }
+    if (h < 0) {
+      h += 1;
+    } else if (h > 1) {
+      h -= 1;
+    }
+  }
+  return {
+    h: h * 360,
+    s,
+    v
+  };
+};
+
+const RGBA_MAX = { b: 256, g: 256, r: 256 };
+const HSV_MAX = { h: 360, s: 1, v: 1 };
+const calculateStepSize = (start, end, steps) => {
+  const step = {};
+  for (const k in start) {
+    if (Object.prototype.hasOwnProperty.call(start, k)) {
+      step[k] = steps === 0 ? 0 : (end[k] - start[k]) / steps;
+    }
+  }
+  return step;
+};
+const interpolate = (step, start, index, max) => {
+  const color = {};
+  for (const k in start) {
+    if (Object.prototype.hasOwnProperty.call(start, k)) {
+      color[k] = step[k] * index + start[k];
+      color[k] = color[k] < 0 ? (
+        // eslint-disable-next-line security/detect-object-injection
+        color[k] + max[k]
+      ) : (
+        // eslint-disable-next-line security/detect-object-injection
+        max[k] === 1 ? (
+          // eslint-disable-next-line security/detect-object-injection
+          color[k]
+        ) : (
+          // eslint-disable-next-line security/detect-object-injection
+          color[k] % max[k]
+        )
+      );
+    }
+  }
+  return color;
+};
+const interpolateRgb = (stop1, stop2, steps) => {
+  const start = { b: stop1.color[2], g: stop1.color[1], r: stop1.color[0] };
+  const end = { b: stop2.color[2], g: stop2.color[1], r: stop2.color[0] };
+  const step = calculateStepSize(start, end, steps);
+  const gradient = [{ ...start }];
+  for (let index = 1; index < steps; index++) {
+    const color = interpolate(step, start, index, RGBA_MAX);
+    gradient.push({
+      b: Math.floor(color.b),
+      g: Math.floor(color.g),
+      r: Math.floor(color.r)
+    });
+  }
+  return gradient;
+};
+const interpolateHsv = (stop1, stop2, steps, mode) => {
+  const start = rgbToHsv({ b: stop1.color[2], g: stop1.color[1], r: stop1.color[0] });
+  const end = rgbToHsv({ b: stop2.color[2], g: stop2.color[1], r: stop2.color[0] });
+  if (start.s === 0 || end.s === 0) {
+    return interpolateRgb(stop1, stop2, steps);
+  }
+  let trigonometric;
+  if (typeof mode === "boolean") {
+    trigonometric = mode;
+  } else {
+    const trigShortest = start.h < end.h && end.h - start.h < 180 || start.h > end.h && start.h - end.h > 180;
+    trigonometric = mode === "long" && trigShortest || mode === "short" && !trigShortest;
+  }
+  const step = calculateStepSize(start, end, steps);
+  const gradient = [
+    {
+      b: stop1.color[2],
+      g: stop1.color[1],
+      r: stop1.color[0]
+    }
+  ];
+  let diff;
+  if (start.h <= end.h && !trigonometric || start.h >= end.h && trigonometric) {
+    diff = end.h - start.h;
+  } else if (trigonometric) {
+    diff = 360 - end.h + start.h;
+  } else {
+    diff = 360 - start.h + end.h;
+  }
+  step.h = (-1) ** (trigonometric ? 1 : 0) * Math.abs(diff) / steps;
+  for (let index = 1; index < steps; index++) {
+    const color = interpolate(step, start, index, HSV_MAX);
+    gradient.push(hsvToRgb(color.h, color.s, color.v));
+  }
+  return gradient;
+};
+
+class GradientBuilder {
+  #colorize;
+  stops;
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  constructor(colorize, stops) {
+    this.#colorize = colorize;
+    this.stops = [];
+    if (stops.length < 2) {
+      throw new Error("Invalid number of stops (< 2)");
+    }
+    const havingPositions = stops[0].position !== void 0;
+    let l = stops.length;
+    let p = -1;
+    let lastColorLess = false;
+    for (const [index, stop_] of stops.entries()) {
+      let stop = {};
+      const hasPosition = stop_.position !== void 0;
+      if (havingPositions !== hasPosition) {
+        throw new Error("Cannot mix positioned and non-positioned color stops");
+      }
+      if (hasPosition) {
+        const stopInput = stop_;
+        const hasColor = stopInput.color !== void 0;
+        if (!hasColor && (lastColorLess || index === 0 || index === l - 1)) {
+          throw new Error("Cannot define two consecutive position-only stops");
+        }
+        lastColorLess = !hasColor;
+        let color;
+        if (hasColor) {
+          if (Array.isArray(stopInput.color)) {
+            color = stopInput.color;
+          } else if (typeof stopInput.color === "string") {
+            color = stopInput.color.includes("#") ? convertHexToRgb(stopInput.color) : colorNames[stopInput.color];
+          } else if (stopInput.color.r !== void 0 && stopInput.color.g !== void 0 && stopInput.color.b) {
+            color = [stopInput.color.r, stopInput.color.g, stopInput.color.b];
+          }
+        }
+        stop = {
+          color,
+          colorLess: !hasColor,
+          position: stopInput.position
+        };
+        if (stop.position < 0 || stop.position > 1) {
+          throw new Error("Color stops positions must be between 0 and 1");
+        } else if (stop.position < p) {
+          throw new Error("Color stops positions are not ordered");
+        }
+        p = stop.position;
+      } else if (Array.isArray(stop_)) {
+        stop = {
+          color: stop_,
+          position: index / (l - 1)
+        };
+      } else if (typeof stop_ === "string") {
+        stop = {
+          color: stop_.includes("#") ? convertHexToRgb(stop_) : colorNames[stop_],
+          position: index / (l - 1)
+        };
+      } else if (stop_.r !== void 0 && stop_.g !== void 0 && stop_.b !== void 0) {
+        stop = {
+          color: [stop_.r, stop_.g, stop_.b],
+          position: index / (l - 1)
+        };
+      } else {
+        throw new Error("Invalid color stop");
+      }
+      this.stops.push(stop);
+    }
+    if (this.stops[0].position !== 0) {
+      this.stops.unshift({
+        color: this.stops[0].color,
+        position: 0
+      });
+      l++;
+    }
+    if (this.stops[l - 1].position !== 1) {
+      this.stops.push({
+        color: this.stops[l - 1].color,
+        position: 1
+      });
+    }
+  }
+  reverse() {
+    const stops = [];
+    for (const stop of this.stops) {
+      const stop_ = { ...stop };
+      stop_.position = 1 - stop.position;
+      stops.push(stop_);
+    }
+    return new GradientBuilder(this.#colorize, stops.reverse());
+  }
+  loop() {
+    const stops1 = [];
+    const stops2 = [];
+    for (const stop of this.stops) {
+      stops1.push({
+        color: stop.color,
+        position: (stop.position || 0) / 2
+      });
+    }
+    for (const stop of this.stops.slice(0, -1)) {
+      stops2.push({
+        color: stop.color,
+        position: 1 - (stop.position || 0) / 2
+      });
+    }
+    return new GradientBuilder(this.#colorize, [...stops1, ...stops2.reverse()]);
+  }
+  rgb(steps) {
+    const subSteps = computeSubSteps(this.stops, steps);
+    const gradient = [];
+    this.stops.forEach((stop, index) => {
+      if (stop.colorLess) {
+        const rgbs = interpolateRgb(this.stops[index - 1], this.stops[index + 1], 2);
+        stop.color = [rgbs[1].r, rgbs[1].g, rgbs[1].b];
+      }
+    });
+    for (let index = 0, l = this.stops.length; index < l - 1; index++) {
+      const rgbs = interpolateRgb(this.stops[index], this.stops[index + 1], subSteps[index]);
+      gradient.splice(gradient.length, 0, ...rgbs.map((rgb) => this.#colorize.rgb(rgb.r, rgb.g, rgb.b)));
+    }
+    gradient.push(this.#colorize.rgb(...this.stops.at(-1).color));
+    return gradient;
+  }
+  hsv(steps, mode = false) {
+    const subSteps = computeSubSteps(this.stops, steps);
+    const gradient = [];
+    this.stops.forEach((stop, index) => {
+      if (stop.colorLess) {
+        const rgbs = interpolateHsv(this.stops[index - 1], this.stops[index + 1], 2, mode);
+        stop.color = [rgbs[1].r, rgbs[1].g, rgbs[1].b];
+      }
+    });
+    for (let index = 0, l = this.stops.length; index < l - 1; index++) {
+      const rgbs = interpolateHsv(this.stops[index], this.stops[index + 1], subSteps[index], mode);
+      gradient.splice(gradient.length, 0, ...rgbs.map((rgb) => this.#colorize.rgb(rgb.r, rgb.g, rgb.b)));
+    }
+    gradient.push(this.#colorize.rgb(...this.stops.at(-1).color));
+    return gradient;
+  }
+}
+
+export { GradientBuilder };