@visulima/colorize 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/packem_shared/GradientBuilder-BXOgJeHi.cjs

@@ -1,490 +0,0 @@
-'use strict';
-
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-
-const convertHexToRgb = require('./convertHexToRgb-DvkHBM3-.cjs');
-
-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.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.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, 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;
-  }
-}
-
-exports.GradientBuilder = GradientBuilder;