colorlyjs/dist/util/GenericsUtil.js

A library for parsing colors within the sRGB color space. it includes rgb(a), hsl(a), hsv(a), hex and cmyk. It mainly focuses on web standards, which is why it has build in css support. However, it may be used in any application that follows the css color

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * @author DeckerM7
 * @since 20220411
 */
var GenericsUtil = /*#__PURE__*/_createClass(function GenericsUtil() {
  _classCallCheck(this, GenericsUtil);
});

_defineProperty(GenericsUtil, "maxRGB", 255);

_defineProperty(GenericsUtil, "maxDecimalPercentage", 1);

_defineProperty(GenericsUtil, "maxIntPercentage", 100);

_defineProperty(GenericsUtil, "validArrayLength", [3, 4]);

_defineProperty(GenericsUtil, "standardHue", 60);

_defineProperty(GenericsUtil, "maxHue", 360);

_defineProperty(GenericsUtil, "hex", 16);

_defineProperty(GenericsUtil, "hexPrefix", "#");

_defineProperty(GenericsUtil, "validHexLength", [3, 4, 6, 8]);

_defineProperty(GenericsUtil, "hexNoTransparency", "FF");

_defineProperty(GenericsUtil, "zero", 0);

_defineProperty(GenericsUtil, "getHexTransparency", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  param = GenericsUtil.convertToHarmonizedHexValue(param);
  return GenericsUtil.isEigthDigitHexValue(param) ? GenericsUtil.__convertHexToArray(param)[3] : GenericsUtil.hexNoTransparency;
});

_defineProperty(GenericsUtil, "convertToHarmonizedHexValue", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  param = GenericsUtil.__removeLeadingHashtag(param).toUpperCase();
  /*if (GenericsUtil.isThreeDigitHexValue(param))
    param = GenericsUtil.__fillThreeDigitHexString(param);*/

  return param;
});

_defineProperty(GenericsUtil, "convertHexIntValueToString", function (param) {
  if (!GenericsUtil.__isNumeric(param)) return;
  param = param.toString(GenericsUtil.hex).toUpperCase();
  return GenericsUtil.isHexString(param) ? param : undefined;
});

_defineProperty(GenericsUtil, "convertHexStringToIntValue", function (param) {
  if (!GenericsUtil.isHexString(param)) return;
  return parseInt(GenericsUtil.__removeLeadingHashtag(param), GenericsUtil.hex);
});

_defineProperty(GenericsUtil, "isHexValue", function (param) {
  return GenericsUtil.isHexString(param) || GenericsUtil.isHexIntValue(param);
});

_defineProperty(GenericsUtil, "isThreeDigitHexValue", function (param) {
  if (!GenericsUtil.isHexValue(param)) return false;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  return GenericsUtil.__getHexRegex(GenericsUtil.validHexLength[0]).test(param) || GenericsUtil.__getHexRegexWithPrefix(GenericsUtil.validHexLength[0]).test(param);
});

_defineProperty(GenericsUtil, "isSixDigitHexValue", function (param) {
  if (!GenericsUtil.isHexValue(param)) return false;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  return GenericsUtil.__getHexRegex(GenericsUtil.validHexLength[2]).test(param) || GenericsUtil.__getHexRegexWithPrefix(GenericsUtil.validHexLength[2]).test(param);
});

_defineProperty(GenericsUtil, "isEigthDigitHexValue", function (param) {
  if (!GenericsUtil.isHexValue(param)) return false;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  return GenericsUtil.__getHexRegex(GenericsUtil.validHexLength[3]).test(param) || GenericsUtil.__getHexRegexWithPrefix(GenericsUtil.validHexLength[3]).test(param);
});

_defineProperty(GenericsUtil, "isHexString", function (param) {
  return GenericsUtil.__isString(param) && GenericsUtil.validHexLength.some(function (e) {
    return GenericsUtil.__getHexRegex(e).test(param) || GenericsUtil.__getHexRegexWithPrefix(e).test(param);
  });
});

_defineProperty(GenericsUtil, "isHexIntValue", function (param) {
  return GenericsUtil.__isNumeric(param) && GenericsUtil.isHexString(GenericsUtil.convertHexIntValueToString(param));
});

_defineProperty(GenericsUtil, "isHexWithTransparency", function (param) {
  if (!GenericsUtil.isHexValue(param)) return false;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  return GenericsUtil.isEigthDigitHexValue(param);
});

_defineProperty(GenericsUtil, "__fillThreeDigitHexString", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  if (!GenericsUtil.isThreeDigitHexValue(param)) return param;
  return param.split(GenericsUtil.__getHexRegex(1)).map(function (e) {
    return "".concat(e).concat(e);
  }).join("");
});

_defineProperty(GenericsUtil, "__convertHexToArray", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  if (GenericsUtil.isHexIntValue(param)) param = GenericsUtil.convertHexIntValueToString(param);
  var conversionObjectLiteral = {
    3: GenericsUtil.__convertThreeDigitHexToArray,
    4: GenericsUtil.__convertThreeDigitHexToArray,
    6: GenericsUtil.__convertSixOrEightDigitHexToArray,
    8: GenericsUtil.__convertSixOrEightDigitHexToArray
  };
  param = GenericsUtil.__removeLeadingHashtag(param);
  return conversionObjectLiteral[param.length](param);
});

_defineProperty(GenericsUtil, "__convertThreeDigitHexToArray", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;

  var arr = GenericsUtil.__splitHexString(param, 1);

  arr = arr.map(function (e) {
    return "".concat(e).concat(e);
  });
  return arr;
});

_defineProperty(GenericsUtil, "__convertSixOrEightDigitHexToArray", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  return GenericsUtil.__splitHexString(param, 2);
});

_defineProperty(GenericsUtil, "__splitHexString", function (hexString, digits) {
  if (!GenericsUtil.isHexValue(hexString)) return;
  return hexString.match(new RegExp("[0-9a-fA-F]{".concat(digits, "}"), "gi"));
});

_defineProperty(GenericsUtil, "__removeLeadingHashtag", function (param) {
  if (!GenericsUtil.isHexValue(param)) return;
  return param.replace(GenericsUtil.hexPrefix, "").toUpperCase();
});

_defineProperty(GenericsUtil, "__getHexRegex", function (digits) {
  return new RegExp("^[0-9a-fA-F]{".concat(digits, "}$"), "gi");
});

_defineProperty(GenericsUtil, "__getHexRegexWithPrefix", function (digits) {
  return new RegExp("^".concat(GenericsUtil.hexPrefix, "[0-9a-fA-F]{").concat(digits, "}$"), "gi");
});

_defineProperty(GenericsUtil, "getValueFromRGBA", function () {
  var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 255;
  var g = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
  var b = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 255;
  var rgb = [r, g, b];
  if (!GenericsUtil.isRGBArray(rgb)) return;
  rgb = GenericsUtil.normalizeRGBArray(rgb);
  var v = Math.max.apply(Math, _toConsumableArray(rgb));
  return v;
});

_defineProperty(GenericsUtil, "getSaturationFromRGBA", function () {
  var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 255;
  var g = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
  var b = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 255;
  var rgb = [r, g, b];
  if (!GenericsUtil.isRGBArray(rgb)) return;
  var l = GenericsUtil.getLuminosityFromRGBA.apply(GenericsUtil, _toConsumableArray(rgb));
  rgb = GenericsUtil.normalizeRGBArray(rgb);
  if (Math.min.apply(Math, _toConsumableArray(rgb)) === 1) return 1;
  if (l === 1 || Math.max.apply(Math, _toConsumableArray(rgb)) === 0) return 0;
  return (Math.max.apply(Math, _toConsumableArray(rgb)) - Math.min.apply(Math, _toConsumableArray(rgb))) / (1 - Math.abs(2 * l - 1));
});

_defineProperty(GenericsUtil, "getHueFromRGBA", function () {
  var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 255;
  var g = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
  var b = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 255;
  var rgb = [r, g, b];
  if (!GenericsUtil.isRGBArray(rgb)) return;
  rgb = GenericsUtil.normalizeRGBArray(rgb);
  var h = GenericsUtil.standardHue;

  if (rgb[0] >= rgb[1] && rgb[1] >= rgb[2]) {
    h = h * ((rgb[1] - rgb[2]) / (rgb[0] - rgb[2]));
  } else if (rgb[1] > rgb[0] && rgb[0] >= rgb[2]) {
    h = h * (2 - (rgb[0] - rgb[2]) / (rgb[1] - rgb[2]));
  } else if (rgb[1] >= rgb[2] && rgb[2] > rgb[0]) {
    h = h * (2 + (rgb[2] - rgb[0]) / (rgb[1] - rgb[0]));
  } else if (rgb[2] > rgb[1] && rgb[1] > rgb[0]) {
    h = h * (4 - (rgb[1] - rgb[0]) / (rgb[2] - rgb[0]));
  } else if (rgb[2] > rgb[0] && rgb[0] >= rgb[1]) {
    h = h * (4 + (rgb[0] - rgb[1]) / (rgb[2] - rgb[1]));
  } else if (rgb[0] >= rgb[2] && rgb[2] > rgb[1]) {
    h = h * (6 - (rgb[2] - rgb[1]) / (rgb[0] - rgb[1]));
  } else {
    h = 0;
  }

  return h === null || isNaN(h) || h === undefined ? 0 : h;
});

_defineProperty(GenericsUtil, "getLuminosityFromRGBA", function () {
  var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 255;
  var g = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 255;
  var b = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 255;
  var rgb = [r, g, b];
  if (!GenericsUtil.isRGBArray(rgb)) return;
  rgb = GenericsUtil.normalizeRGBArray(rgb);
  return 0.5 * (Math.max.apply(Math, _toConsumableArray(rgb)) + Math.min.apply(Math, _toConsumableArray(rgb)));
});

_defineProperty(GenericsUtil, "normalizeRGBArray", function (param) {
  if (!GenericsUtil.isRGBArray(param)) return;
  return param.map(function (e) {
    return GenericsUtil.normalizeRGBValue(e);
  });
});

_defineProperty(GenericsUtil, "normalizeRGBAArray", function (param) {
  if (!GenericsUtil.isRGBAArray(param)) return;
  return param.map(function (e, i) {
    return i < GenericsUtil.validArrayLength[0] ? GenericsUtil.normalizeRGBValue(e) : e;
  });
});

_defineProperty(GenericsUtil, "normalizeRGBValue", function (param) {
  if (!GenericsUtil.isRGBValue(param)) return;
  return param / GenericsUtil.maxRGB;
});

_defineProperty(GenericsUtil, "getValueFromNormalizedRGBValue", function (param) {
  if (!GenericsUtil.isNormalizedRGBValue(param)) return;
  return param * GenericsUtil.maxRGB;
});

_defineProperty(GenericsUtil, "isRGBValue", function (param) {
  return param <= GenericsUtil.maxRGB && param >= GenericsUtil.zero;
});

_defineProperty(GenericsUtil, "isNormalizedRGBValue", function (param) {
  return GenericsUtil.isDecimalPercentage(param);
});

_defineProperty(GenericsUtil, "isRGBAAlphaValue", function (param) {
  return GenericsUtil.isDecimalPercentage(param);
});

_defineProperty(GenericsUtil, "isRGBArray", function (param) {
  return GenericsUtil.isThreeElementsArray(param) && param.every(function (e) {
    return GenericsUtil.isRGBValue(e);
  });
});

_defineProperty(GenericsUtil, "isRGBAArray", function (param) {
  return GenericsUtil.isFourElementsArray(param) && param.every(function (e, i) {
    return i < GenericsUtil.validArrayLength[0] && GenericsUtil.isRGBValue(e) || GenericsUtil.isRGBAAlphaValue(e);
  });
});

_defineProperty(GenericsUtil, "isCMYKValue", function (param) {
  return GenericsUtil.isDecimalPercentage(param);
});

_defineProperty(GenericsUtil, "isCMYKArray", function (param) {
  return GenericsUtil.isFourElementsArray(param) && param.every(function (e) {
    return GenericsUtil.isCMYKValue(e);
  });
});

_defineProperty(GenericsUtil, "isHSLValue", function (param) {
  return GenericsUtil.isDecimalPercentage(param);
});

_defineProperty(GenericsUtil, "isHSLArray", function (param) {
  return GenericsUtil.isThreeElementsArray(param) && param.every(function (e, i) {
    return i === GenericsUtil.zero ? GenericsUtil.isHueValue(e) : GenericsUtil.isHSLValue(e);
  });
});

_defineProperty(GenericsUtil, "isHSVValue", function (param) {
  return GenericsUtil.isDecimalPercentage(param);
});

_defineProperty(GenericsUtil, "isHueValue", function (param) {
  GenericsUtil.__isNumeric(param);

  return GenericsUtil.__isNumeric(param) && param >= GenericsUtil.zero && param <= GenericsUtil.maxHue;
});

_defineProperty(GenericsUtil, "isHSVArray", function (param) {
  return GenericsUtil.isThreeElementsArray(param) && param.every(function (e, i) {
    return i === GenericsUtil.zero ? GenericsUtil.isHueValue(e) : GenericsUtil.isHSVValue(e);
  });
});

_defineProperty(GenericsUtil, "roundNumberToInfinity", function (number, precision) {
  if (!GenericsUtil.__isNumeric(number)) return;
  if (Number.isInteger(number)) return number;
  if (precision === 0) return Math.ceil(number);
  var numberString = number.toFixed(precision + 3); // we need some more digits than the expected precision

  var _numberString$split = numberString.split("."),
      _numberString$split2 = _slicedToArray(_numberString$split, 2),
      integer = _numberString$split2[0],
      decimalPoints = _numberString$split2[1];

  decimalPoints = decimalPoints.replace(/0*$/gi, "");
  if (decimalPoints.length === 0) return parseInt(integer);
  if (decimalPoints.length <= precision) return parseFloat("".concat(integer, ".").concat(decimalPoints));
  var keptDecimalPoints = decimalPoints.substr(0, precision),
      removedDecimalPoints = decimalPoints.substr(precision, decimalPoints.length);
  var splitDecimalPoints = /[0-9]/gi;
  var keptArray = keptDecimalPoints.match(splitDecimalPoints).map(function (e) {
    return parseInt(e);
  }),
      removedArray = removedDecimalPoints.match(splitDecimalPoints).map(function (e) {
    return parseInt(e);
  });
  if (/^5[0]*$/gi.test(removedDecimalPoints) && keptArray[keptArray.length - 1] % 2 === 1 || removedArray[0] >= 5 && removedArray.some(function (e, i) {
    return i === 0 ? false : e !== 0;
  })) keptArray[keptArray.length - 1] = keptArray[keptArray.length - 1] + 1;
  return parseFloat("".concat(integer, ".").concat(keptArray.join("")));
});

_defineProperty(GenericsUtil, "isDecimalPercentage", function (param) {
  return GenericsUtil.__isNumeric(param) && param <= GenericsUtil.maxDecimalPercentage && param >= GenericsUtil.zero;
});

_defineProperty(GenericsUtil, "isIntPercentage", function (param) {
  return GenericsUtil.__isNumeric(param) && param <= GenericsUtil.maxIntPercentage && param >= GenericsUtil.zero;
});

_defineProperty(GenericsUtil, "isFourElementsArray", function (arr) {
  return GenericsUtil.isObject(arr) && arr.length === GenericsUtil.validArrayLength[1];
});

_defineProperty(GenericsUtil, "isThreeElementsArray", function (arr) {
  return GenericsUtil.isObject(arr) && arr.length === GenericsUtil.validArrayLength[0];
});

_defineProperty(GenericsUtil, "isObject", function (param) {
  return _typeof(param) === "object";
});

_defineProperty(GenericsUtil, "isNumberOrString", function (param) {
  return GenericsUtil.__isNumeric(param) || GenericsUtil.____isString(param);
});

_defineProperty(GenericsUtil, "__isNumeric", function (param) {
  return typeof param === "number";
});

_defineProperty(GenericsUtil, "__isString", function (param) {
  return typeof param === "string";
});

var _default = GenericsUtil;
exports["default"] = _default;