@etsoo/shared 1.1.14 → 1.1.15

package/README.md

@@ -18,6 +18,17 @@ $ yarn add @etsoo/shared
 ## storage
 Storage interface and browser storage implementation
 
+## EColor
+Etsoo implmented Color
+
+|Name|Description|
+|---:|---|
+|static getColors|Get HEX or RGB colors|
+|static getEColors|Get EColors|
+|static parse|Parse HTML color to EColor|
+|toHEXColor|To HEX color string|
+|toRGBColor|To RGB color string|
+
 ## Keyboard
 Keyboard keys and codes
 

package/__tests__/EColor.ts

@@ -0,0 +1,17 @@
+import { EColor } from '../src/types/EColor';
+
+test('Tests for parse', () => {
+    // Arrange & act
+    const colorShort = EColor.parse('#000');
+    const color = EColor.parse('#e21821');
+    const colorRgb = EColor.parse('RGB(226, 24, 33)');
+
+    // Assert
+    expect(colorShort?.toRGBColor()).toBe('RGB(0, 0, 0)');
+    expect(color?.toRGBColor()).toBe('RGB(226, 24, 33)');
+    expect(colorRgb?.toHEXColor()).toBe('#e21821');
+});
+
+test('Tests for getColors', () => {
+    expect(EColor.getColors(undefined, 128).length).toBe(8);
+});

package/lib/cjs/index.d.ts

@@ -1,5 +1,6 @@
-export * from './types/FormData';
 export * from './types/DelayedExecutorType';
+export * from './types/EColor';
+export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './DataTypes';

package/lib/cjs/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -10,8 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types/FormData"), exports);
 __exportStar(require("./types/DelayedExecutorType"), exports);
+__exportStar(require("./types/EColor"), exports);
+__exportStar(require("./types/FormData"), exports);
 __exportStar(require("./storage/IStorage"), exports);
 __exportStar(require("./storage/WindowStorage"), exports);
 __exportStar(require("./DataTypes"), exports);

package/lib/cjs/types/EColor.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Etsoo implmented Color
+ */
+export declare class EColor {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha?: number | undefined;
+    /**
+     * Adjust value
+     * @param value Current value
+     * @param adjust Adjust value
+     * @returns Adjusted value
+     */
+    static adjust(value: number, adjust?: number): number;
+    /**
+     * Get HEX or RGB colors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @param hex to HEX or not
+     * @returns Result
+     */
+    static getColors(init?: string, factor?: number, hex?: boolean): string[];
+    /**
+     * Get EColors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @returns Result
+     */
+    static getEColors(init?: string, factor?: number): EColor[];
+    /**
+     * HEX string to integer value
+     * @param hex HEX string
+     * @returns Integer value
+     */
+    static hexTo(hex: string): number;
+    /**
+     * Format value to 16 radix string
+     * @param num Int value
+     * @returns Result
+     */
+    static toHex(num: number): string;
+    /**
+     * Parse HTML color to EColor
+     * @param htmlColor HTML color
+     * @returns EColor
+     */
+    static parse(htmlColor?: string | null): EColor | undefined;
+    /**
+     * Constructor
+     * @param r Reg
+     * @param g Green
+     * @param b Blue
+     * @param alpha Alpha
+     */
+    constructor(r: number, g: number, b: number, alpha?: number | undefined);
+    /**
+     * Clone color with adjusts
+     * @param adjustR Adjust R value
+     * @param adjustG Adjust G value
+     * @param adjustB Adjust B value
+     * @param alpha New alpha value
+     */
+    clone(adjustR?: number, adjustG?: number, adjustB?: number, alpha?: number): EColor | undefined;
+    /**
+     * To RGB color string
+     * @param includeAlpha Include alpha or not
+     * @returns RGB color string
+     */
+    toRGBColor(includeAlpha?: boolean): string;
+    /**
+     * To HEX color string
+     * @returns HEX color string
+     */
+    toHEXColor(): string;
+}

package/lib/cjs/types/EColor.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EColor = void 0;
+/**
+ * Etsoo implmented Color
+ */
+class EColor {
+    /**
+     * Constructor
+     * @param r Reg
+     * @param g Green
+     * @param b Blue
+     * @param alpha Alpha
+     */
+    constructor(r, g, b, alpha) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.alpha = alpha;
+    }
+    /**
+     * Adjust value
+     * @param value Current value
+     * @param adjust Adjust value
+     * @returns Adjusted value
+     */
+    static adjust(value, adjust) {
+        if (adjust == null)
+            return value;
+        value = Math.abs(value + adjust);
+        if (value > 255)
+            return value % 255;
+        return value;
+    }
+    /**
+     * Get HEX or RGB colors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @param hex to HEX or not
+     * @returns Result
+     */
+    static getColors(init = '#000', factor = 51, hex = true) {
+        return EColor.getEColors(init, factor).map((c) => hex ? c.toHEXColor() : c.toRGBColor());
+    }
+    /**
+     * Get EColors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @returns Result
+     */
+    static getEColors(init = '#000', factor = 51) {
+        var _a;
+        // Init color
+        const initColor = (_a = EColor.parse(init)) !== null && _a !== void 0 ? _a : new EColor(0, 0, 0);
+        // Factors elements
+        // 51 = '00', '33', '66', '99', 'cc', 'ff'
+        const factors = [];
+        let f = 0;
+        while (f <= 255) {
+            factors.push(f);
+            f += factor;
+        }
+        // RGB loop
+        const colors = [initColor];
+        for (const r of factors) {
+            for (const g of factors) {
+                for (const b of factors) {
+                    const newColor = initColor.clone(r, g, b);
+                    if (newColor)
+                        colors.push(newColor);
+                }
+            }
+        }
+        return colors;
+    }
+    /**
+     * HEX string to integer value
+     * @param hex HEX string
+     * @returns Integer value
+     */
+    static hexTo(hex) {
+        return parseInt(hex, 16);
+    }
+    /**
+     * Format value to 16 radix string
+     * @param num Int value
+     * @returns Result
+     */
+    static toHex(num) {
+        return num.toString(16).padStart(2, '0');
+    }
+    /**
+     * Parse HTML color to EColor
+     * @param htmlColor HTML color
+     * @returns EColor
+     */
+    static parse(htmlColor) {
+        // Null
+        if (htmlColor == null)
+            return undefined;
+        htmlColor = htmlColor.toUpperCase();
+        // HEX color
+        if (htmlColor.startsWith('#')) {
+            htmlColor = htmlColor.substring(1);
+            if (htmlColor.length === 3)
+                htmlColor = Array.from(htmlColor)
+                    .map((c) => c + c)
+                    .join('');
+            if (htmlColor.length === 6) {
+                return new EColor(EColor.hexTo(htmlColor.substring(0, 2)), EColor.hexTo(htmlColor.substring(2, 4)), EColor.hexTo(htmlColor.substring(4, 6)));
+            }
+            return undefined;
+        }
+        // For RGB and RGBA
+        const reg = /^RGBA?\(([0-9,\s\.]+)\)$/;
+        const result = htmlColor.match(reg);
+        if (result != null && result.length == 2) {
+            const parts = result[1].split(/\s*,\s*/);
+            if (parts.length === 3 || parts.length === 4) {
+                const alpha = parts[3];
+                return new EColor(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), alpha == null ? undefined : parseFloat(alpha));
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Clone color with adjusts
+     * @param adjustR Adjust R value
+     * @param adjustG Adjust G value
+     * @param adjustB Adjust B value
+     * @param alpha New alpha value
+     */
+    clone(adjustR, adjustG, adjustB, alpha) {
+        const r = EColor.adjust(this.r, adjustR);
+        const g = EColor.adjust(this.g, adjustG);
+        const b = EColor.adjust(this.b, adjustB);
+        if (r === this.r &&
+            g === this.g &&
+            b === this.b &&
+            (alpha == null || alpha === this.alpha))
+            return undefined;
+        return new EColor(r, g, b, alpha);
+    }
+    /**
+     * To RGB color string
+     * @param includeAlpha Include alpha or not
+     * @returns RGB color string
+     */
+    toRGBColor(includeAlpha) {
+        var _a;
+        // Default case
+        includeAlpha !== null && includeAlpha !== void 0 ? includeAlpha : (includeAlpha = this.alpha != null);
+        if (includeAlpha)
+            return `RGBA(${this.r}, ${this.g}, ${this.b}, ${(_a = this.alpha) !== null && _a !== void 0 ? _a : 1})`;
+        return `RGB(${this.r}, ${this.g}, ${this.b})`;
+    }
+    /**
+     * To HEX color string
+     * @returns HEX color string
+     */
+    toHEXColor() {
+        return `#${EColor.toHex(this.r)}${EColor.toHex(this.g)}${EColor.toHex(this.b)}`;
+    }
+}
+exports.EColor = EColor;

package/lib/mjs/index.d.ts

@@ -1,5 +1,6 @@
-export * from './types/FormData';
 export * from './types/DelayedExecutorType';
+export * from './types/EColor';
+export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './DataTypes';

package/lib/mjs/index.js

@@ -1,5 +1,6 @@
-export * from './types/FormData';
 export * from './types/DelayedExecutorType';
+export * from './types/EColor';
+export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './DataTypes';

package/lib/mjs/types/EColor.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Etsoo implmented Color
+ */
+export declare class EColor {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly alpha?: number | undefined;
+    /**
+     * Adjust value
+     * @param value Current value
+     * @param adjust Adjust value
+     * @returns Adjusted value
+     */
+    static adjust(value: number, adjust?: number): number;
+    /**
+     * Get HEX or RGB colors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @param hex to HEX or not
+     * @returns Result
+     */
+    static getColors(init?: string, factor?: number, hex?: boolean): string[];
+    /**
+     * Get EColors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @returns Result
+     */
+    static getEColors(init?: string, factor?: number): EColor[];
+    /**
+     * HEX string to integer value
+     * @param hex HEX string
+     * @returns Integer value
+     */
+    static hexTo(hex: string): number;
+    /**
+     * Format value to 16 radix string
+     * @param num Int value
+     * @returns Result
+     */
+    static toHex(num: number): string;
+    /**
+     * Parse HTML color to EColor
+     * @param htmlColor HTML color
+     * @returns EColor
+     */
+    static parse(htmlColor?: string | null): EColor | undefined;
+    /**
+     * Constructor
+     * @param r Reg
+     * @param g Green
+     * @param b Blue
+     * @param alpha Alpha
+     */
+    constructor(r: number, g: number, b: number, alpha?: number | undefined);
+    /**
+     * Clone color with adjusts
+     * @param adjustR Adjust R value
+     * @param adjustG Adjust G value
+     * @param adjustB Adjust B value
+     * @param alpha New alpha value
+     */
+    clone(adjustR?: number, adjustG?: number, adjustB?: number, alpha?: number): EColor | undefined;
+    /**
+     * To RGB color string
+     * @param includeAlpha Include alpha or not
+     * @returns RGB color string
+     */
+    toRGBColor(includeAlpha?: boolean): string;
+    /**
+     * To HEX color string
+     * @returns HEX color string
+     */
+    toHEXColor(): string;
+}

package/lib/mjs/types/EColor.js

@@ -0,0 +1,161 @@
+/**
+ * Etsoo implmented Color
+ */
+export class EColor {
+    /**
+     * Constructor
+     * @param r Reg
+     * @param g Green
+     * @param b Blue
+     * @param alpha Alpha
+     */
+    constructor(r, g, b, alpha) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.alpha = alpha;
+    }
+    /**
+     * Adjust value
+     * @param value Current value
+     * @param adjust Adjust value
+     * @returns Adjusted value
+     */
+    static adjust(value, adjust) {
+        if (adjust == null)
+            return value;
+        value = Math.abs(value + adjust);
+        if (value > 255)
+            return value % 255;
+        return value;
+    }
+    /**
+     * Get HEX or RGB colors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @param hex to HEX or not
+     * @returns Result
+     */
+    static getColors(init = '#000', factor = 51, hex = true) {
+        return EColor.getEColors(init, factor).map((c) => hex ? c.toHEXColor() : c.toRGBColor());
+    }
+    /**
+     * Get EColors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @returns Result
+     */
+    static getEColors(init = '#000', factor = 51) {
+        var _a;
+        // Init color
+        const initColor = (_a = EColor.parse(init)) !== null && _a !== void 0 ? _a : new EColor(0, 0, 0);
+        // Factors elements
+        // 51 = '00', '33', '66', '99', 'cc', 'ff'
+        const factors = [];
+        let f = 0;
+        while (f <= 255) {
+            factors.push(f);
+            f += factor;
+        }
+        // RGB loop
+        const colors = [initColor];
+        for (const r of factors) {
+            for (const g of factors) {
+                for (const b of factors) {
+                    const newColor = initColor.clone(r, g, b);
+                    if (newColor)
+                        colors.push(newColor);
+                }
+            }
+        }
+        return colors;
+    }
+    /**
+     * HEX string to integer value
+     * @param hex HEX string
+     * @returns Integer value
+     */
+    static hexTo(hex) {
+        return parseInt(hex, 16);
+    }
+    /**
+     * Format value to 16 radix string
+     * @param num Int value
+     * @returns Result
+     */
+    static toHex(num) {
+        return num.toString(16).padStart(2, '0');
+    }
+    /**
+     * Parse HTML color to EColor
+     * @param htmlColor HTML color
+     * @returns EColor
+     */
+    static parse(htmlColor) {
+        // Null
+        if (htmlColor == null)
+            return undefined;
+        htmlColor = htmlColor.toUpperCase();
+        // HEX color
+        if (htmlColor.startsWith('#')) {
+            htmlColor = htmlColor.substring(1);
+            if (htmlColor.length === 3)
+                htmlColor = Array.from(htmlColor)
+                    .map((c) => c + c)
+                    .join('');
+            if (htmlColor.length === 6) {
+                return new EColor(EColor.hexTo(htmlColor.substring(0, 2)), EColor.hexTo(htmlColor.substring(2, 4)), EColor.hexTo(htmlColor.substring(4, 6)));
+            }
+            return undefined;
+        }
+        // For RGB and RGBA
+        const reg = /^RGBA?\(([0-9,\s\.]+)\)$/;
+        const result = htmlColor.match(reg);
+        if (result != null && result.length == 2) {
+            const parts = result[1].split(/\s*,\s*/);
+            if (parts.length === 3 || parts.length === 4) {
+                const alpha = parts[3];
+                return new EColor(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]), alpha == null ? undefined : parseFloat(alpha));
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Clone color with adjusts
+     * @param adjustR Adjust R value
+     * @param adjustG Adjust G value
+     * @param adjustB Adjust B value
+     * @param alpha New alpha value
+     */
+    clone(adjustR, adjustG, adjustB, alpha) {
+        const r = EColor.adjust(this.r, adjustR);
+        const g = EColor.adjust(this.g, adjustG);
+        const b = EColor.adjust(this.b, adjustB);
+        if (r === this.r &&
+            g === this.g &&
+            b === this.b &&
+            (alpha == null || alpha === this.alpha))
+            return undefined;
+        return new EColor(r, g, b, alpha);
+    }
+    /**
+     * To RGB color string
+     * @param includeAlpha Include alpha or not
+     * @returns RGB color string
+     */
+    toRGBColor(includeAlpha) {
+        var _a;
+        // Default case
+        includeAlpha !== null && includeAlpha !== void 0 ? includeAlpha : (includeAlpha = this.alpha != null);
+        if (includeAlpha)
+            return `RGBA(${this.r}, ${this.g}, ${this.b}, ${(_a = this.alpha) !== null && _a !== void 0 ? _a : 1})`;
+        return `RGB(${this.r}, ${this.g}, ${this.b})`;
+    }
+    /**
+     * To HEX color string
+     * @returns HEX color string
+     */
+    toHEXColor() {
+        return `#${EColor.toHex(this.r)}${EColor.toHex(this.g)}${EColor.toHex(this.b)}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.1.14",
+    "version": "1.1.15",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -55,13 +55,13 @@
     "dependencies": {},
     "devDependencies": {
         "@types/jest": "^27.4.1",
-        "@typescript-eslint/eslint-plugin": "^5.12.1",
-        "@typescript-eslint/parser": "^5.12.1",
+        "@typescript-eslint/eslint-plugin": "^5.13.0",
+        "@typescript-eslint/parser": "^5.13.0",
         "eslint": "^8.10.0",
         "eslint-config-airbnb-base": "^15.0.0",
         "eslint-plugin-import": "^2.25.4",
         "jest": "^27.5.1",
         "ts-jest": "^27.1.3",
-        "typescript": "^4.5.5"
+        "typescript": "^4.6.2"
     }
 }

package/src/index.ts

@@ -1,5 +1,6 @@
-export * from './types/FormData';
 export * from './types/DelayedExecutorType';
+export * from './types/EColor';
+export * from './types/FormData';
 
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';

package/src/types/EColor.ts

@@ -0,0 +1,195 @@
+/**
+ * Etsoo implmented Color
+ */
+export class EColor {
+    /**
+     * Adjust value
+     * @param value Current value
+     * @param adjust Adjust value
+     * @returns Adjusted value
+     */
+    static adjust(value: number, adjust?: number) {
+        if (adjust == null) return value;
+        value = Math.abs(value + adjust);
+        if (value > 255) return value % 255;
+        return value;
+    }
+
+    /**
+     * Get HEX or RGB colors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @param hex to HEX or not
+     * @returns Result
+     */
+    static getColors(init = '#000', factor: number = 51, hex: boolean = true) {
+        return EColor.getEColors(init, factor).map((c) =>
+            hex ? c.toHEXColor() : c.toRGBColor()
+        );
+    }
+
+    /**
+     * Get EColors
+     * @param init Initial color
+     * @param factor Increase factor
+     * @returns Result
+     */
+    static getEColors(init = '#000', factor: number = 51): EColor[] {
+        // Init color
+        const initColor = EColor.parse(init) ?? new EColor(0, 0, 0);
+
+        // Factors elements
+        // 51 = '00', '33', '66', '99', 'cc', 'ff'
+        const factors: number[] = [];
+        let f = 0;
+        while (f <= 255) {
+            factors.push(f);
+            f += factor;
+        }
+
+        // RGB loop
+        const colors: EColor[] = [initColor];
+
+        for (const r of factors) {
+            for (const g of factors) {
+                for (const b of factors) {
+                    const newColor = initColor.clone(r, g, b);
+                    if (newColor) colors.push(newColor);
+                }
+            }
+        }
+
+        return colors;
+    }
+
+    /**
+     * HEX string to integer value
+     * @param hex HEX string
+     * @returns Integer value
+     */
+    static hexTo(hex: string) {
+        return parseInt(hex, 16);
+    }
+
+    /**
+     * Format value to 16 radix string
+     * @param num Int value
+     * @returns Result
+     */
+    static toHex(num: number) {
+        return num.toString(16).padStart(2, '0');
+    }
+
+    /**
+     * Parse HTML color to EColor
+     * @param htmlColor HTML color
+     * @returns EColor
+     */
+    static parse(htmlColor?: string | null): EColor | undefined {
+        // Null
+        if (htmlColor == null) return undefined;
+        htmlColor = htmlColor.toUpperCase();
+
+        // HEX color
+        if (htmlColor.startsWith('#')) {
+            htmlColor = htmlColor.substring(1);
+            if (htmlColor.length === 3)
+                htmlColor = Array.from(htmlColor)
+                    .map((c) => c + c)
+                    .join('');
+
+            if (htmlColor.length === 6) {
+                return new EColor(
+                    EColor.hexTo(htmlColor.substring(0, 2)),
+                    EColor.hexTo(htmlColor.substring(2, 4)),
+                    EColor.hexTo(htmlColor.substring(4, 6))
+                );
+            }
+
+            return undefined;
+        }
+
+        // For RGB and RGBA
+        const reg = /^RGBA?\(([0-9,\s\.]+)\)$/;
+        const result = htmlColor.match(reg);
+        if (result != null && result.length == 2) {
+            const parts = result[1].split(/\s*,\s*/);
+            if (parts.length === 3 || parts.length === 4) {
+                const alpha = parts[3];
+                return new EColor(
+                    parseInt(parts[0]),
+                    parseInt(parts[1]),
+                    parseInt(parts[2]),
+                    alpha == null ? undefined : parseFloat(alpha)
+                );
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Constructor
+     * @param r Reg
+     * @param g Green
+     * @param b Blue
+     * @param alpha Alpha
+     */
+    constructor(
+        public readonly r: number,
+        public readonly g: number,
+        public readonly b: number,
+        public readonly alpha?: number
+    ) {}
+
+    /**
+     * Clone color with adjusts
+     * @param adjustR Adjust R value
+     * @param adjustG Adjust G value
+     * @param adjustB Adjust B value
+     * @param alpha New alpha value
+     */
+    clone(
+        adjustR?: number,
+        adjustG?: number,
+        adjustB?: number,
+        alpha?: number
+    ) {
+        const r = EColor.adjust(this.r, adjustR);
+        const g = EColor.adjust(this.g, adjustG);
+        const b = EColor.adjust(this.b, adjustB);
+        if (
+            r === this.r &&
+            g === this.g &&
+            b === this.b &&
+            (alpha == null || alpha === this.alpha)
+        )
+            return undefined;
+        return new EColor(r, g, b, alpha);
+    }
+
+    /**
+     * To RGB color string
+     * @param includeAlpha Include alpha or not
+     * @returns RGB color string
+     */
+    toRGBColor(includeAlpha?: boolean) {
+        // Default case
+        includeAlpha ??= this.alpha != null;
+
+        if (includeAlpha)
+            return `RGBA(${this.r}, ${this.g}, ${this.b}, ${this.alpha ?? 1})`;
+
+        return `RGB(${this.r}, ${this.g}, ${this.b})`;
+    }
+
+    /**
+     * To HEX color string
+     * @returns HEX color string
+     */
+    toHEXColor() {
+        return `#${EColor.toHex(this.r)}${EColor.toHex(this.g)}${EColor.toHex(
+            this.b
+        )}`;
+    }
+}