colorlyjs/dist/ColorFactory.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;

var _GenericsUtil = _interopRequireDefault(require("./util/GenericsUtil.js"));

var _ParserUtil = _interopRequireDefault(require("./util/ParserUtil.js"));

var _CSSUtil = _interopRequireDefault(require("./util/CSSUtil.js"));

var _CSSColors = _interopRequireDefault(require("./util/CSSColors.js"));

var _Color = _interopRequireDefault(require("./model/Color.js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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; }

var ColorFactory = /*#__PURE__*/_createClass(function ColorFactory() {
  _classCallCheck(this, ColorFactory);
});

_defineProperty(ColorFactory, "modes", {
  css: "css",
  hex: "hex",
  rgb: "rgb",
  rgba: "rgba",
  cmyk: "cmyk",
  hsl: "hsl",
  hsv: "hsv",
  name: "name"
});

_defineProperty(ColorFactory, "createColor", function (mode, a, b, c, d) {
  var modes = {
    css: ColorFactory.createColorFromCSSString,
    hex: ColorFactory.createColorFromHex,
    rgb: ColorFactory.createColorFromRGB,
    rgba: ColorFactory.createColorFromRGBA,
    cmyk: ColorFactory.createColorFromCMYK,
    hsl: ColorFactory.createColorFromHSL,
    hsv: ColorFactory.createColorFromHSV,
    name: ColorFactory.createColorFromNamedCSSColor
  };
  return modes[mode] ? modes[mode](a, b, c, d) : undefined;
});

_defineProperty(ColorFactory, "createColorFromHex", function (hex) {
  if (!_GenericsUtil["default"].isHexValue(hex)) return;

  var rgba = _ParserUtil["default"].parseHexToRGBA(_GenericsUtil["default"].convertToHarmonizedHexValue(hex));

  return _construct(_Color["default"], _toConsumableArray(rgba));
});

_defineProperty(ColorFactory, "createColorFromRGB", function (r, g, b) {
  if (!_GenericsUtil["default"].isRGBArray([r, g, b])) return;
  return new _Color["default"](r, g, b);
});

_defineProperty(ColorFactory, "createColorFromRGBA", function (r, g, b, a) {
  if (!_GenericsUtil["default"].isRGBAArray([r, g, b, a])) return;
  return new _Color["default"](r, g, b, a);
});

_defineProperty(ColorFactory, "createColorFromCMYK", function (c, m, y, k) {
  if (!_GenericsUtil["default"].isCMYKArray([c, m, y, k])) return;
  return _construct(_Color["default"], _toConsumableArray(_ParserUtil["default"].parseCMYKToRGBA(c, m, y, k)));
});

_defineProperty(ColorFactory, "createColorFromHSL", function (h, s, l) {
  if (!_GenericsUtil["default"].isHSLArray([h, s, l])) return;
  return _construct(_Color["default"], _toConsumableArray(_ParserUtil["default"].parseHSLToRGBA(h, s, l)));
});

_defineProperty(ColorFactory, "createColorFromHSV", function (h, s, v) {
  if (!_GenericsUtil["default"].isHSVArray([h, s, v])) return;
  return _construct(_Color["default"], _toConsumableArray(_ParserUtil["default"].parseHSVToRGBA(h, s, v)));
});

_defineProperty(ColorFactory, "createColorFromCSSString", function (cssStr) {
  var color;

  if (cssStr.indexOf(_CSSUtil["default"].hexPrefix) === 0) {
    color = ColorFactory.createColorFromHexCSSString(cssStr);
  } else if (cssStr.indexOf(_CSSUtil["default"].rgbaPrefix) === 0) {
    color = ColorFactory.createColorFromRGBACSSString(cssStr);
  } else if (cssStr.indexOf(_CSSUtil["default"].rgbPrefix) === 0) {
    color = ColorFactory.createColorFromRGBCSSString(cssStr);
  } else if (cssStr.indexOf(_CSSUtil["default"].cmykPrefix) === 0) {
    color = ColorFactory.createColorFromCMYKCSSString(cssStr);
  } else if (cssStr.indexOf(_CSSUtil["default"].hslPrefix) === 0) {
    color = ColorFactory.createColorFromHSLCSSString(cssStr);
  } else if (cssStr.indexOf(_CSSUtil["default"].hsvPrefix) === 0) {
    color = ColorFactory.createColorFromHSVCSSString(cssStr);
  } else {
    return;
  }

  return color;
});

_defineProperty(ColorFactory, "createColorFromHexCSSString", function (cssStr) {
  var hex = _CSSUtil["default"].cssStringToHarmonizedHexString(cssStr);

  return hex ? ColorFactory.createColorFromHex(hex) : undefined;
});

_defineProperty(ColorFactory, "createColorFromRGBCSSString", function (cssStr) {
  var rgb = _CSSUtil["default"].cssStringToRGBArray(cssStr);

  return rgb ? ColorFactory.createColorFromRGB.apply(ColorFactory, _toConsumableArray(rgb)) : undefined;
});

_defineProperty(ColorFactory, "createColorFromRGBACSSString", function (cssStr) {
  var rgba = _CSSUtil["default"].cssStringToRGBAArray(cssStr);

  return rgba ? ColorFactory.createColorFromRGBA.apply(ColorFactory, _toConsumableArray(rgba)) : undefined;
});

_defineProperty(ColorFactory, "createColorFromCMYKCSSString", function (cssStr) {
  var cmyk = _CSSUtil["default"].cssStringToCMYKArray(cssStr);

  return cmyk ? ColorFactory.createColorFromCMYK.apply(ColorFactory, _toConsumableArray(cmyk)) : undefined;
});

_defineProperty(ColorFactory, "createColorFromHSLCSSString", function (cssStr) {
  var hsl = _CSSUtil["default"].cssStringToHSLArray(cssStr);

  return hsl ? ColorFactory.createColorFromHSL.apply(ColorFactory, _toConsumableArray(hsl)) : undefined;
});

_defineProperty(ColorFactory, "createColorFromHSVCSSString", function (cssStr) {
  var hsv = _CSSUtil["default"].cssStringToHSVArray(cssStr);

  return hsv ? ColorFactory.createColorFromHSV.apply(ColorFactory, _toConsumableArray(hsv)) : undefined;
});

_defineProperty(ColorFactory, "createColorFromNamedCSSColor", function (colorName) {
  if (!_CSSColors["default"][colorName]) return;
  return ColorFactory.createColorFromHexCSSString(_CSSColors["default"][colorName]);
});

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