@zcrkey/js-utils 0.0.6 → 0.0.7

package/dist/esm/color.d.ts

@@ -0,0 +1,195 @@
+export default class CrColorUtil {
+    /**
+     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     */
+    static hexToRgb(hex: string): number[];
+    /**
+     * rgb 转 hex 标准格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+    static rgbToHex(r: number, g: number, b: number): string;
+    /**
+     * 将 rgb 格式转为 hsv 格式
+     * input: r,g,b in [0,1], out: h in [0,360) and s,v in [0,1]
+     * @param r 0-1
+     * @param g 0-1
+     * @param b 0-1
+     */
+    static rgb2hsv(r: number, g: number, b: number): number[];
+    /**
+     * 将 hsv 格式转为 rgb 格式
+     * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
+     * @param h 0-360
+     * @param s 0-1
+     * @param v 0-1
+     */
+    static hsv2rgb(h: number, s: number, v: number): number[];
+    /**
+     * hex 转 rgba 格式字符串 可直接用于css
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: rgba(255,255,255,0.5)
+     */
+    static hexToRgba(hex: string, alpha?: number): string;
+    /**
+     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: #ffffff80  #ff000033
+     */
+    static hexAddAlpha(hex: string, alpha?: number): string;
+    /**
+     * rgba 转 hex 格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+    static rgbaToHex(r: number, g: number, b: number): string;
+    /**
+     * hsv 转 hex 十六进制颜色
+     * @param h 色相 0-360
+     * @param s 饱和度 0-1
+     * @param v 明度 0-1
+     */
+    static hsvToHex(h: number, s: number, v: number): string;
+    /**
+     * hex 转 hsv 格式
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns [h:0-360, s:0-1, v:0-1]
+     */
+    static hexToHsv(hex: string): number[];
+    /**
+     * 颜色加深处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
+     */
+    static darkenColor(hex: string, level: number): string;
+    /**
+     * 颜色减淡/提亮处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
+     */
+    static lightenColor(hex: string, level: number): string;
+    /**
+     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
+     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+    static parseHex8(hex8: string): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * rgb 数组 转 rgb/rgba 字符串
+     * @param rgb [r,g,b] 0-255
+     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
+     */
+    static rgbToStr(rgb: number[], alpha?: number): string;
+    /**
+     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
+     */
+    static hexToNumber(hex: string): number;
+    /**
+     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
+     * @param num 十进制数值 例：16711680 → #ff0000
+     * @returns 标准6位十六进制颜色 #RRGGBB 格式
+     */
+    static numberToHex(num: number): string;
+    /**
+   * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
+   * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
+   * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
+   */
+    static argbToNumber(argb: string): number;
+    /**
+     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
+     * @param num 十进制数值 例：2147483647 → #80ffffff
+     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
+     */
+    static numberToArgb(num: number): string;
+    /**
+     * 生成随机Hex颜色
+     * @param withSharp 是否带#号 默认为true
+     * @returns 随机hex颜色
+     */
+    static randomHexColor(withSharp?: boolean): string;
+    /**
+     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
+     * @param hex 目标颜色
+     * @returns 反色hex
+     */
+    static reverseColor(hex: string): string;
+    /**
+     * 校验是否为合法的hex颜色
+     * @param hex 待校验的颜色字符串
+     * @returns true=合法 false=不合法
+     */
+    static isHexColor(hex: string): boolean;
+    /**
+     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
+     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
+     * @param alpha 透明度 0~1  默认 1 (完全不透明)
+     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
+     */
+    static hexToArgb(hex: string, alpha?: number): string;
+    /**
+     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
+     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
+     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
+     */
+    static argbToHex(argb: string): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
+     * @param argb #AARRGGBB
+     * @returns #RRGGBBAA
+     */
+    static argbToRgbaHex(argb: string): string;
+    /**
+     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
+     * @param rgbaHex #RRGGBBAA
+     * @returns #AARRGGBB
+     */
+    static rgbaHexToArgb(rgbaHex: string): string;
+    /**
+     * 调整颜色饱和度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
+     * @returns 调整后的hex颜色
+     */
+    static adjustSaturation(hex: string, level: number): string;
+    /**
+     * 调整颜色明度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
+     * @returns 调整后的hex颜色
+     */
+    static adjustBrightness(hex: string, level: number): string;
+    /**
+     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
+     * @param hex 支持 #fff / #ffffff 格式
+     * @param alpha 透明度 0-1
+     * @returns ARGB十进制数值
+     */
+    static hexAlphaToArgbNumber(hex: string, alpha?: number): number;
+    /**
+     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
+     * @param num ARGB十进制数值
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+    static argbNumberToHexAlpha(num: number): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * 补零成两位字符
+     */
+    private static twoDigits;
+}

package/dist/esm/color.js

@@ -0,0 +1,500 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 _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 _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+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, _toPropertyKey(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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var CrColorUtil = /*#__PURE__*/function () {
+  function CrColorUtil() {
+    _classCallCheck(this, CrColorUtil);
+  }
+  _createClass(CrColorUtil, null, [{
+    key: "hexToRgb",
+    value:
+    /**
+     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     */
+    function hexToRgb(hex) {
+      var hexVal = hex.replace("#", "");
+      if (hexVal.length === 3) {
+        hexVal = hexVal.split('').map(function (c) {
+          return c + c;
+        }).join('');
+      }
+      var hexInt = parseInt(hexVal, 16);
+      var r = hexInt >> 16 & 255;
+      var g = hexInt >> 8 & 255;
+      var b = hexInt & 255;
+      return [r, g, b];
+    }
+
+    /**
+     * rgb 转 hex 标准格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+  }, {
+    key: "rgbToHex",
+    value: function rgbToHex(r, g, b) {
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, Math.round(val)));
+      };
+      var red = clamp(r);
+      var green = clamp(g);
+      var blue = clamp(b);
+      return "#" + this.twoDigits(red.toString(16)) + this.twoDigits(green.toString(16)) + this.twoDigits(blue.toString(16));
+    }
+
+    /**
+     * 将 rgb 格式转为 hsv 格式
+     * input: r,g,b in [0,1], out: h in [0,360) and s,v in [0,1]
+     * @param r 0-1
+     * @param g 0-1
+     * @param b 0-1
+     */
+  }, {
+    key: "rgb2hsv",
+    value: function rgb2hsv(r, g, b) {
+      var v = Math.max(r, g, b);
+      var n = v - Math.min(r, g, b);
+      var h = n && (v == r ? (g - b) / n : v == g ? 2 + (b - r) / n : 4 + (r - g) / n);
+      return [60 * (h < 0 ? h + 6 : h), v && n / v, v];
+    }
+
+    /**
+     * 将 hsv 格式转为 rgb 格式
+     * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
+     * @param h 0-360
+     * @param s 0-1
+     * @param v 0-1
+     */
+  }, {
+    key: "hsv2rgb",
+    value: function hsv2rgb(h, s, v) {
+      var f = function f(n) {
+        var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 60) % 6;
+        return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+      };
+      return [f(5), f(3), f(1)];
+    }
+
+    /**
+     * hex 转 rgba 格式字符串 可直接用于css
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: rgba(255,255,255,0.5)
+     */
+  }, {
+    key: "hexToRgba",
+    value: function hexToRgba(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var _this$hexToRgb = this.hexToRgb(hex),
+        _this$hexToRgb2 = _slicedToArray(_this$hexToRgb, 3),
+        r = _this$hexToRgb2[0],
+        g = _this$hexToRgb2[1],
+        b = _this$hexToRgb2[2];
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(validAlpha, ")");
+    }
+
+    /**
+     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: #ffffff80  #ff000033
+     */
+  }, {
+    key: "hexAddAlpha",
+    value: function hexAddAlpha(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var pureHex = hex.replace('#', '');
+      pureHex = pureHex.length === 3 ? pureHex.split('').map(function (char) {
+        return char + char;
+      }).join('') : pureHex;
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+      return "#".concat(pureHex).concat(alphaHex);
+    }
+
+    /**
+     * rgba 转 hex 格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+  }, {
+    key: "rgbaToHex",
+    value: function rgbaToHex(r, g, b) {
+      return this.rgbToHex(r, g, b);
+    }
+
+    /**
+     * hsv 转 hex 十六进制颜色
+     * @param h 色相 0-360
+     * @param s 饱和度 0-1
+     * @param v 明度 0-1
+     */
+  }, {
+    key: "hsvToHex",
+    value: function hsvToHex(h, s, v) {
+      var _this$hsv2rgb = this.hsv2rgb(h, s, v),
+        _this$hsv2rgb2 = _slicedToArray(_this$hsv2rgb, 3),
+        r = _this$hsv2rgb2[0],
+        g = _this$hsv2rgb2[1],
+        b = _this$hsv2rgb2[2];
+      return this.rgbToHex(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
+    }
+
+    /**
+     * hex 转 hsv 格式
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns [h:0-360, s:0-1, v:0-1]
+     */
+  }, {
+    key: "hexToHsv",
+    value: function hexToHsv(hex) {
+      var _this$hexToRgb3 = this.hexToRgb(hex),
+        _this$hexToRgb4 = _slicedToArray(_this$hexToRgb3, 3),
+        r = _this$hexToRgb4[0],
+        g = _this$hexToRgb4[1],
+        b = _this$hexToRgb4[2];
+      return this.rgb2hsv(r / 255, g / 255, b / 255);
+    }
+
+    /**
+     * 颜色加深处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
+     */
+  }, {
+    key: "darkenColor",
+    value: function darkenColor(hex, level) {
+      var _this$hexToRgb5 = this.hexToRgb(hex),
+        _this$hexToRgb6 = _slicedToArray(_this$hexToRgb5, 3),
+        r = _this$hexToRgb6[0],
+        g = _this$hexToRgb6[1],
+        b = _this$hexToRgb6[2];
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, val));
+      };
+      var darkR = clamp(r - r * level);
+      var darkG = clamp(g - g * level);
+      var darkB = clamp(b - b * level);
+      return this.rgbToHex(darkR, darkG, darkB);
+    }
+
+    /**
+     * 颜色减淡/提亮处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
+     */
+  }, {
+    key: "lightenColor",
+    value: function lightenColor(hex, level) {
+      var _this$hexToRgb7 = this.hexToRgb(hex),
+        _this$hexToRgb8 = _slicedToArray(_this$hexToRgb7, 3),
+        r = _this$hexToRgb8[0],
+        g = _this$hexToRgb8[1],
+        b = _this$hexToRgb8[2];
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, val));
+      };
+      var lightR = clamp(r + (255 - r) * level);
+      var lightG = clamp(g + (255 - g) * level);
+      var lightB = clamp(b + (255 - b) * level);
+      return this.rgbToHex(lightR, lightG, lightB);
+    }
+
+    /**
+     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
+     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+  }, {
+    key: "parseHex8",
+    value: function parseHex8(hex8) {
+      var pureHex = hex8.replace('#', '');
+      if (pureHex.length !== 8) return {
+        hex: hex8,
+        alpha: 1
+      };
+      var hex = "#".concat(pureHex.slice(0, 6));
+      var alphaHex = pureHex.slice(6);
+      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+      return {
+        hex: hex,
+        alpha: alpha
+      };
+    }
+
+    /**
+     * rgb 数组 转 rgb/rgba 字符串
+     * @param rgb [r,g,b] 0-255
+     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
+     */
+  }, {
+    key: "rgbToStr",
+    value: function rgbToStr(rgb, alpha) {
+      var _rgb = _slicedToArray(rgb, 3),
+        r = _rgb[0],
+        g = _rgb[1],
+        b = _rgb[2];
+      return alpha !== undefined ? "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(Math.max(0, Math.min(1, alpha)), ")") : "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
+    }
+
+    /**
+     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
+     */
+  }, {
+    key: "hexToNumber",
+    value: function hexToNumber(hex) {
+      var pureHex = hex.replace('#', '');
+      // 严谨校验：只允许3位/6位纯十六进制颜色，非法值返回0，避免NaN
+      if (!/^[0-9a-fA-F]{3}|[0-9a-fA-F]{6}$/.test(pureHex)) {
+        return 0;
+      }
+      return parseInt(pureHex, 16);
+    }
+
+    /**
+     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
+     * @param num 十进制数值 例：16711680 → #ff0000
+     * @returns 标准6位十六进制颜色 #RRGGBB 格式
+     */
+  }, {
+    key: "numberToHex",
+    value: function numberToHex(num) {
+      // 位运算拆解R/G/B通道，值范围永远0-255，再转16进制字符串+补零
+      var r = this.twoDigits((num >> 16 & 255).toString(16));
+      var g = this.twoDigits((num >> 8 & 255).toString(16));
+      var b = this.twoDigits((num & 255).toString(16));
+      return "#".concat(r).concat(g).concat(b);
+    }
+
+    /**
+    * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
+    * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
+    * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
+    */
+  }, {
+    key: "argbToNumber",
+    value: function argbToNumber(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (!/^[0-9a-fA-F]{8}$/.test(pureArgb)) {
+        return 0;
+      }
+      return parseInt(pureArgb, 16);
+    }
+
+    /**
+     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
+     * @param num 十进制数值 例：2147483647 → #80ffffff
+     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
+     */
+  }, {
+    key: "numberToArgb",
+    value: function numberToArgb(num) {
+      var a = this.twoDigits((num >> 24 & 255).toString(16));
+      var r = this.twoDigits((num >> 16 & 255).toString(16));
+      var g = this.twoDigits((num >> 8 & 255).toString(16));
+      var b = this.twoDigits((num & 255).toString(16));
+      return "#".concat(a).concat(r).concat(g).concat(b);
+    }
+
+    /**
+     * 生成随机Hex颜色
+     * @param withSharp 是否带#号 默认为true
+     * @returns 随机hex颜色
+     */
+  }, {
+    key: "randomHexColor",
+    value: function randomHexColor() {
+      var withSharp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var hex = this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16));
+      return withSharp ? "#".concat(hex) : hex;
+    }
+
+    /**
+     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
+     * @param hex 目标颜色
+     * @returns 反色hex
+     */
+  }, {
+    key: "reverseColor",
+    value: function reverseColor(hex) {
+      var _this$hexToRgb9 = this.hexToRgb(hex),
+        _this$hexToRgb10 = _slicedToArray(_this$hexToRgb9, 3),
+        r = _this$hexToRgb10[0],
+        g = _this$hexToRgb10[1],
+        b = _this$hexToRgb10[2];
+      return this.rgbToHex(255 - r, 255 - g, 255 - b);
+    }
+
+    /**
+     * 校验是否为合法的hex颜色
+     * @param hex 待校验的颜色字符串
+     * @returns true=合法 false=不合法
+     */
+  }, {
+    key: "isHexColor",
+    value: function isHexColor(hex) {
+      return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(hex);
+    }
+
+    /**
+     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
+     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
+     * @param alpha 透明度 0~1  默认 1 (完全不透明)
+     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
+     */
+  }, {
+    key: "hexToArgb",
+    value: function hexToArgb(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var pureHex = hex.replace('#', '');
+      if (pureHex.length === 3) {
+        pureHex = pureHex.split('').map(function (char) {
+          return char + char;
+        }).join('');
+      }
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+      return "#".concat(alphaHex).concat(pureHex);
+    }
+
+    /**
+     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
+     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
+     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
+     */
+  }, {
+    key: "argbToHex",
+    value: function argbToHex(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (pureArgb.length !== 8) {
+        console.warn('传入的不是合法的ARGB格式，格式必须是 #AARRGGBB');
+        return {
+          hex: argb,
+          alpha: 1
+        };
+      }
+      var alphaHex = pureArgb.slice(0, 2);
+      var hexVal = pureArgb.slice(2);
+      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+      return {
+        hex: "#".concat(hexVal),
+        alpha: alpha
+      };
+    }
+
+    /**
+     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
+     * @param argb #AARRGGBB
+     * @returns #RRGGBBAA
+     */
+  }, {
+    key: "argbToRgbaHex",
+    value: function argbToRgbaHex(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (pureArgb.length !== 8) return argb;
+      return "#".concat(pureArgb.slice(2)).concat(pureArgb.slice(0, 2));
+    }
+
+    /**
+     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
+     * @param rgbaHex #RRGGBBAA
+     * @returns #AARRGGBB
+     */
+  }, {
+    key: "rgbaHexToArgb",
+    value: function rgbaHexToArgb(rgbaHex) {
+      var pureRgba = rgbaHex.replace('#', '');
+      if (pureRgba.length !== 8) return rgbaHex;
+      return "#".concat(pureRgba.slice(6)).concat(pureRgba.slice(0, 6));
+    }
+
+    /**
+     * 调整颜色饱和度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
+     * @returns 调整后的hex颜色
+     */
+  }, {
+    key: "adjustSaturation",
+    value: function adjustSaturation(hex, level) {
+      var _this$hexToHsv = this.hexToHsv(hex),
+        _this$hexToHsv2 = _slicedToArray(_this$hexToHsv, 3),
+        h = _this$hexToHsv2[0],
+        s = _this$hexToHsv2[1],
+        v = _this$hexToHsv2[2];
+      var newS = Math.max(0, Math.min(1, s * level));
+      return this.hsvToHex(h, newS, v);
+    }
+
+    /**
+     * 调整颜色明度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
+     * @returns 调整后的hex颜色
+     */
+  }, {
+    key: "adjustBrightness",
+    value: function adjustBrightness(hex, level) {
+      var _this$hexToHsv3 = this.hexToHsv(hex),
+        _this$hexToHsv4 = _slicedToArray(_this$hexToHsv3, 3),
+        h = _this$hexToHsv4[0],
+        s = _this$hexToHsv4[1],
+        v = _this$hexToHsv4[2];
+      var newV = Math.max(0, Math.min(1, v * level));
+      return this.hsvToHex(h, s, newV);
+    }
+
+    /**
+     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
+     * @param hex 支持 #fff / #ffffff 格式
+     * @param alpha 透明度 0-1
+     * @returns ARGB十进制数值
+     */
+  }, {
+    key: "hexAlphaToArgbNumber",
+    value: function hexAlphaToArgbNumber(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var argbStr = this.hexToArgb(hex, alpha);
+      return this.argbToNumber(argbStr);
+    }
+
+    /**
+     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
+     * @param num ARGB十进制数值
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+  }, {
+    key: "argbNumberToHexAlpha",
+    value: function argbNumberToHexAlpha(num) {
+      var argbStr = this.numberToArgb(num);
+      return this.argbToHex(argbStr);
+    }
+
+    /**
+     * 补零成两位字符
+     */
+  }, {
+    key: "twoDigits",
+    value: function twoDigits(num) {
+      var s = num.toString();
+      return s.length === 1 ? '0' + s : s;
+    }
+  }]);
+  return CrColorUtil;
+}();
+export { CrColorUtil as default };