ace-colorpicker-rpk 0.0.12

package/src/util/functions/formatter.js

@@ -0,0 +1,99 @@
+
+/**
+ * @method format
+ *
+ * convert color to format string
+ *
+ *     // hex
+ *     color.format({ r : 255, g : 255, b : 255, a: 1 }, 'hex')  // #FFFFFFFF
+ *
+ *     // rgb
+ *     color.format({ r : 255, g : 255, b : 255 }, 'rgb') // rgba(255, 255, 255, 0.5);
+ *
+ *     // rgba
+ *     color.format({ r : 255, g : 255, b : 255, a : 0.5 }, 'rgb') // rgba(255, 255, 255, 0.5);
+ *
+ * @param {Object} obj  obj has r, g, b and a attributes
+ * @param {"hex"/"rgb"} type  format string type
+ * @returns {*}
+ */
+export function format(obj, type, defaultColor = 'rgba(0, 0, 0, 0)') {
+
+    if (Array.isArray(obj)) {
+        obj = { r: obj[0], g: obj[1], b: obj[2], a: obj[3] }
+    }
+
+    if (type == 'hex') {
+        return hex(obj);
+    } else if (type == 'rgb') {
+        return rgb(obj, defaultColor);
+    } else if (type == 'hsl') {
+        return hsl(obj);
+    }
+
+    return obj;
+}
+
+export function hex(obj) {
+    if (Array.isArray(obj)) {
+        obj = { r: obj[0], g: obj[1], b: obj[2], a: obj[3] }
+    }
+
+    var r = obj.r.toString(16);
+    if (obj.r < 16) r = "0" + r;
+
+    var g = obj.g.toString(16);
+    if (obj.g < 16) g = "0" + g;
+
+    var b = obj.b.toString(16);
+    if (obj.b < 16) b = "0" + b;
+
+
+    var alphaValue = ''    
+    if (obj.a < 1) {
+        var alpha = Math.floor(obj.a * 255)
+        var alphaValue = alpha.toString(16);
+        if (alpha < 16) alphaValue = "0" + alphaValue;        
+    }
+
+    return `#${r}${g}${b}${alphaValue}`;
+}
+
+export function rgb (obj, defaultColor = 'rgba(0, 0, 0, 0)') {
+    if (Array.isArray(obj)) {
+        obj = { r: obj[0], g: obj[1], b: obj[2], a: obj[3] }
+    }
+
+    if (typeof obj == 'undefined') {
+        return undefined;
+    }
+
+    if (obj.a == 1 || typeof obj.a == 'undefined') {
+        if (isNaN(obj.r)) {
+            return defaultColor;
+        }
+        return `rgb(${obj.r},${obj.g},${obj.b})`;
+    } else {
+        return `rgba(${obj.r},${obj.g},${obj.b},${obj.a})`;
+    }
+}
+
+export function hsl (obj) {
+    if (Array.isArray(obj)) {
+        obj = { r: obj[0], g: obj[1], b: obj[2], a: obj[3] }
+    }
+
+    if (obj.a == 1 || typeof obj.a == 'undefined') {
+        return `hsl(${obj.h},${obj.s}%,${obj.l}%)`;
+    } else {
+        return `hsla(${obj.h},${obj.s}%,${obj.l}%,${obj.a})`;
+    }
+
+}
+
+export default {
+    format,
+    rgb,
+    hsl,
+    hex
+}; 

package/src/util/functions/fromCMYK.js

@@ -0,0 +1,17 @@
+
+export function CMYKtoRGB(c, m, y, k) {
+
+    if (arguments.length == 1) {
+        var { c, m, y, k } = arguments[0];
+    }
+
+    const R = 255 * (1 - c) * (1 - k);
+    const G = 255 * (1 - m) * (1 - k);
+    const B = 255 * (1 - y) * (1 - k);
+
+    return { r: R, g: G, b: B }
+}
+
+export default {
+    CMYKtoRGB
+}

package/src/util/functions/fromHSL.js

@@ -0,0 +1,52 @@
+import { RGBtoHSV } from './fromRGB'
+import { round } from './math'
+
+export function HUEtoRGB(p, q, t) {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 1 / 2) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+}
+
+export function HSLtoHSV(h, s, l) {
+
+    if (arguments.length == 1) {
+        var { h, s, l } = arguments[0];
+    }
+    const rgb = HSLtoRGB(h, s, l);
+
+    return RGBtoHSV(rgb.r, rgb.g, rgb.b);
+}
+
+export function HSLtoRGB(h, s, l) {
+
+    if (arguments.length == 1) {
+        var { h, s, l } = arguments[0];
+    }
+
+    var r, g, b;
+
+    h /= 360;
+    s /= 100;
+    l /= 100;
+
+    if (s == 0) {
+        r = g = b = l; // achromatic
+    } else {
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
+        r = HUEtoRGB(p, q, h + 1 / 3);
+        g = HUEtoRGB(p, q, h);
+        b = HUEtoRGB(p, q, h - 1 / 3);
+    }
+
+    return { r: round(r * 255), g: round(g * 255), b: round(b * 255) };
+}
+
+export default {
+    HUEtoRGB,
+    HSLtoHSV,
+    HSLtoRGB
+}

package/src/util/functions/fromHSV.js

@@ -0,0 +1,64 @@
+import { round } from './math'
+import { RGBtoHSL } from './fromRGB'
+
+/**
+ * @method HSVtoRGB
+ *
+ * convert hsv to rgb
+ *
+ * 		color.HSVtoRGB(0,0,1) === #FFFFF === { r : 255, g : 0, b : 0 }
+ *
+ * @param {Number} H  hue color number  (min : 0, max : 360)
+ * @param {Number} S  Saturation number  (min : 0, max : 1)
+ * @param {Number} V  Value number 		(min : 0, max : 1 )
+ * @returns {Object}
+ */
+export function HSVtoRGB(h, s, v) {
+
+    if (arguments.length == 1) {
+        var { h, s, v } = arguments[0];
+    }
+
+    var H = h;
+    var S = s;
+    var V = v;
+
+    if (H >= 360) {
+        H = 0;
+    }
+
+    const C = S * V;
+    const X = C * (1 - Math.abs((H / 60) % 2 - 1));
+    const m = V - C;
+
+    let temp = [];
+
+    if (0 <= H && H < 60) { temp = [C, X, 0]; }
+    else if (60 <= H && H < 120) { temp = [X, C, 0]; }
+    else if (120 <= H && H < 180) { temp = [0, C, X]; }
+    else if (180 <= H && H < 240) { temp = [0, X, C]; }
+    else if (240 <= H && H < 300) { temp = [X, 0, C]; }
+    else if (300 <= H && H < 360) { temp = [C, 0, X]; }
+
+    return {
+        r: round((temp[0] + m) * 255),
+        g: round((temp[1] + m) * 255),
+        b: round((temp[2] + m) * 255)
+    };
+}
+
+export function HSVtoHSL(h, s, v) {
+
+    if (arguments.length == 1) {
+        var { h, s, v } = arguments[0];
+    }
+
+    const rgb = HSVtoRGB(h, s, v);
+
+    return RGBtoHSL(rgb.r, rgb.g, rgb.b);
+}
+
+export default {
+    HSVtoHSL,
+    HSVtoRGB
+}

package/src/util/functions/fromLAB.js

@@ -0,0 +1,99 @@
+import { round } from './math'
+
+export function ReverseXyz(n) {
+    return (Math.pow(n, 3) > 0.008856) ? Math.pow(n, 3) : (n - 16 / 116) / 7.787;
+}
+
+export function ReverseRGB(n) {
+    return (n > 0.0031308) ? 1.055 * (Math.pow(n, (1 / 2.4))) - 0.055 : 12.92 * n;
+}
+
+export function XYZtoRGB(x, y, z) {
+    if (arguments.length == 1) {
+        var { x, y, z } = arguments[0];
+    }
+    //X, Y and Z input refer to a D65/2° standard illuminant.
+    //sR, sG and sB (standard RGB) output range = 0 ÷ 255
+
+    let X = x / 100.0
+    let Y = y / 100.0
+    let Z = z / 100.0
+
+    let R = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
+    let G = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
+    let B = X * 0.0557 + Y * -0.2040 + Z * 1.0570;
+
+    R = ReverseRGB(R);
+    G = ReverseRGB(G);
+    B = ReverseRGB(B);
+
+    const r = round(R * 255);
+    const g = round(G * 255);
+    const b = round(B * 255);
+
+    return { r, g, b };
+}
+
+export function LABtoXYZ(l, a, b) {
+    if (arguments.length == 1) {
+        var { l, a, b } = arguments[0];
+    }
+    //Reference-X, Y and Z refer to specific illuminants and observers.
+    //Common reference values are available below in this same page.
+
+    let Y = (l + 16) / 116
+    let X = a / 500 + Y
+    let Z = Y - b / 200
+
+    Y = ReverseXyz(Y);
+    X = ReverseXyz(X);
+    Z = ReverseXyz(Z);
+
+    const x = X * 95.047
+    const y = Y * 100.000
+    const z = Z * 108.883
+
+    return { x, y, z };
+}
+
+export function PivotXyz(n) {
+    return (n > 0.008856) ? Math.pow(n, (1 / 3)) : (7.787 * n + 16) / 116;
+}
+
+
+export function XYZtoLAB(x, y, z) {
+    if (arguments.length == 1) {
+        var { x, y, z } = arguments[0];
+    }
+
+    //Reference-X, Y and Z refer to specific illuminants and observers.
+    //Common reference values are available below in this same page.
+    // Observer= 2°, Illuminant= D65
+
+    let X = x / 95.047;
+    let Y = y / 100.00;
+    let Z = z / 108.883;
+
+    X = PivotXyz(X);
+    Y = PivotXyz(Y);
+    Z = PivotXyz(Z);
+
+    const l = (116 * Y) - 16;
+    const a = 500 * (X - Y);
+    const b = 200 * (Y - Z);
+
+    return { l, a, b };
+}
+
+export function LABtoRGB(l, a, b) {
+    if (arguments.length == 1) {
+        var { l, a, b } = arguments[0];
+    }
+    return XYZtoRGB(LABtoXYZ(l, a, b));
+}
+
+export default {
+    XYZtoRGB,
+    LABtoRGB,
+    LABtoXYZ
+}

package/src/util/functions/fromRGB.js

@@ -0,0 +1,220 @@
+import { round } from './math'
+import { parse } from './parser';
+
+/**
+ * @method RGBtoHSV
+ *
+ * convert rgb to hsv
+ *
+ * 		color.RGBtoHSV(0, 0, 255) === { h : 240, s : 1, v : 1 } === '#FFFF00'
+ *
+ * @param {Number} R  red color value
+ * @param {Number} G  green color value
+ * @param {Number} B  blue color value
+ * @return {Object}  hsv color code
+ */
+export function RGBtoHSV(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+
+    const R1 = r / 255;
+    const G1 = g / 255;
+    const B1 = b / 255;
+
+    const MaxC = Math.max(R1, G1, B1);
+    const MinC = Math.min(R1, G1, B1);
+
+    const DeltaC = MaxC - MinC;
+
+    var H = 0;
+
+    if (DeltaC == 0) { H = 0; }
+    else if (MaxC == R1) {
+        H = 60 * (((G1 - B1) / DeltaC) % 6);
+    } else if (MaxC == G1) {
+        H = 60 * (((B1 - R1) / DeltaC) + 2);
+    } else if (MaxC == B1) {
+        H = 60 * (((R1 - G1) / DeltaC) + 4);
+    }
+
+    if (H < 0) {
+        H = 360 + H;
+    }
+
+    var S = 0;
+
+    if (MaxC == 0) S = 0;
+    else S = DeltaC / MaxC;
+
+    var V = MaxC;
+
+    return { h: H, s: S, v: V };
+}
+
+
+export function RGBtoCMYK(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+
+    const R1 = r / 255;
+    const G1 = g / 255;
+    const B1 = b / 255;
+
+    const K = 1 - Math.max(R1, G1, B1);
+    const C = (1 - R1 - K) / (1 - K);
+    const M = (1 - G1 - K) / (1 - K);
+    const Y = (1 - B1 - K) / (1 - K);
+
+    return { c: C, m: M, y: Y, k: K };
+}
+
+
+export function RGBtoHSL(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+
+    r /= 255, g /= 255, b /= 255;
+    var max = Math.max(r, g, b), min = Math.min(r, g, b);
+    var h, s, l = (max + min) / 2;
+
+    if (max == min) {
+        h = s = 0; // achromatic
+    } else {
+        var d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+            case g: h = (b - r) / d + 2; break;
+            case b: h = (r - g) / d + 4; break;
+        }
+        h /= 6;
+    }
+
+    return { h: round(h * 360), s: round(s * 100), l: round(l * 100) };
+}
+
+export function c(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+    return gray((r + g + b) / 3 > 90 ? 0 : 255);
+}
+
+export function gray(gray) {
+    return { r: gray, g: gray, b: gray };
+}
+
+export function RGBtoSimpleGray(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+    return gray(Math.ceil((r + g + b) / 3));
+}
+
+
+export function RGBtoGray(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+    return gray(RGBtoYCrCb(r, g, b).y);
+}
+
+
+export function brightness(r, g, b) {
+        return Math.ceil(r * 0.2126 + g * 0.7152 + b * 0.0722);
+}
+
+export const luminance = brightness;
+
+export function relativeLuminance (r, g, b) {
+    let R = (r / 255)
+    let G = (g / 255)
+    let B = (b / 255)
+
+    R = PivotRGB(R, 0.03928);
+    G = PivotRGB(G, 0.03928);
+    B = PivotRGB(B, 0.03928);
+
+    return luminance(R, G, B);
+}
+
+export function contrastRatio (color1, color2) {
+    var c1 = parse(color1);
+    var c2 = parse(color2);
+
+    var L1 = relativeLuminance(c1.r, c1.g, c1.b);
+    var L2 = relativeLuminance(c2.r, c2.g, c2.b);
+
+    return (L1 + 0.05) / (L2 + 0.05)
+}
+
+
+
+export function RGBtoYCrCb(r, g, b) {
+
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+    const Y = brightness(r, g, b);
+    const Cb = 0.564 * (b - Y)
+    const Cr = 0.713 * (r - Y)
+
+    return { y: Y, cr: Cr, cb: Cb };
+}
+
+export function PivotRGB(n, point = 0.04045) {
+    return ((n > point) ? Math.pow((n + 0.055) / 1.055, 2.4) : n / 12.92) * 100;
+}
+
+
+export function RGBtoXYZ(r, g, b) {
+    //sR, sG and sB (Standard RGB) input range = 0 ÷ 255
+    //X, Y and Z output refer to a D65/2° standard illuminant.
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+
+    let R = (r / 255)
+    let G = (g / 255)
+    let B = (b / 255)
+
+    R = PivotRGB(R);
+    G = PivotRGB(G);
+    B = PivotRGB(B);
+
+    const x = R * 0.4124 + G * 0.3576 + B * 0.1805;
+    const y = R * 0.2126 + G * 0.7152 + B * 0.0722;
+    const z = R * 0.0193 + G * 0.1192 + B * 0.9505;
+
+    return { x, y, z }
+}
+    
+export function RGBtoLAB(r, g, b) {
+    if (arguments.length == 1) {
+        var { r, g, b } = arguments[0];
+    }
+    return XYZtoLAB(RGBtoXYZ(r, g, b));
+}
+
+export default {
+    RGBtoCMYK,
+    RGBtoGray,
+    RGBtoHSL,
+    RGBtoHSV,
+    RGBtoLAB,
+    RGBtoSimpleGray,
+    RGBtoXYZ,
+    RGBtoYCrCb,
+    c,
+    brightness,
+    gray
+}

package/src/util/functions/fromYCrCb.js

@@ -0,0 +1,16 @@
+export function YCrCbtoRGB(y, cr, cb, bit) {
+
+    if (arguments.length == 1) {
+        var { y, cr, cb, bit } = arguments[0];
+        bit = bit || 0;
+    }
+    const R = y + 1.402 * (cr - bit);
+    const G = y - 0.344 * (cb - bit) - 0.714 * (cr - bit);
+    const B = y + 1.772 * (cb - bit);
+
+    return { r: Math.ceil(R), g: Math.ceil(G), b: Math.ceil(B) }
+}
+
+export default {
+    YCrCbtoRGB
+}