@mhmdhammoud/meritt-utils 1.0.6 → 1.2.0

package/dist/__tests__/colorful.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/colorful.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = require("../lib");
+describe('Colorful Class', () => {
+    describe('rgbToHex method', () => {
+        it('should convert RGB to HEX', () => {
+            const rgbColor = 'rgb(255, 255, 255)';
+            const hexColor = lib_1.Colorful.rgbToHex(rgbColor);
+            expect(hexColor).toBe('#ffffff');
+        });
+        it('should convert RGBA to HEX', () => {
+            const rgbaColor = 'rgba(255, 0, 0, 0.5)';
+            const hexColor = lib_1.Colorful.rgbToHex(rgbaColor);
+            expect(hexColor).toBe('#ff0000');
+        });
+        it('should throw an error for invalid color format', () => {
+            const invalidColor = 'invalidColor';
+            expect(() => lib_1.Colorful.rgbToHex(invalidColor)).toThrowError(`Invalid color format '${invalidColor}'. Please provide a valid RGB or RGBA color.`);
+        });
+    });
+    describe('hexToRgb method', () => {
+        it('should convert HEX to RGB', () => {
+            const hexColor = '#ffffff';
+            const rgbColor = lib_1.Colorful.hexToRgb(hexColor);
+            expect(rgbColor).toBe('rgb(255, 255, 255)');
+        });
+    });
+    describe('isLightColor method', () => {
+        it('should return true for a light color (HEX format)', () => {
+            const lightHexColor = '#f0f0f0';
+            const isLight = lib_1.Colorful.isLightColor(lightHexColor);
+            expect(isLight).toBe(true);
+        });
+        it('should return false for a dark color (HEX format)', () => {
+            const darkHexColor = '#333333';
+            const isLight = lib_1.Colorful.isLightColor(darkHexColor);
+            expect(isLight).toBe(false);
+        });
+        it('should return true for a light color (RGBA format)', () => {
+            const lightRgbaColor = 'rgba(255, 255, 255, 0.5)';
+            const isLight = lib_1.Colorful.isLightColor(lightRgbaColor);
+            expect(isLight).toBe(true);
+        });
+        it('should return false for a dark color (RGBA format)', () => {
+            const darkRgbaColor = 'rgba(0, 0, 0, 0.8)';
+            const isLight = lib_1.Colorful.isLightColor(darkRgbaColor);
+            expect(isLight).toBe(false);
+        });
+        it('should return true for a light color (RGB format)', () => {
+            const lightRgbColor = 'rgb(200, 220, 255)';
+            const isLight = lib_1.Colorful.isLightColor(lightRgbColor);
+            expect(isLight).toBe(true);
+        });
+        it('should return false for a dark color (RGB format)', () => {
+            const darkRgbColor = 'rgb(10, 20, 30)';
+            const isLight = lib_1.Colorful.isLightColor(darkRgbColor);
+            expect(isLight).toBe(false);
+        });
+        it('should throw an error for an invalid color format', () => {
+            const invalidColor = 'invalid-color';
+            expect(() => lib_1.Colorful.isLightColor(invalidColor)).toThrowError("Invalid color format 'invalid-color'. Please provide a valid HEX, RGB, or RGBA color.");
+        });
+    });
+});

package/dist/__tests__/formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/formatter.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = require("../lib");
+describe('Formatter', () => {
+    describe('toUpperFirst method', () => {
+        it('should format string with - and upper first letter', () => {
+            const formattedString = lib_1.Formatter.toUpperFirst('hello world');
+            expect(formattedString).toBe('Hello-world');
+        });
+        it('should format string with spaces and upper first letter of every word', () => {
+            const formattedString = lib_1.Formatter.toUpperFirst('hello_world+test');
+            expect(formattedString).toBe('Hello-world-test');
+        });
+        it('should throw an error for non-string input', () => {
+            expect(() => lib_1.Formatter.toUpperFirst(123)).toThrowError('Provide a valid string');
+        });
+    });
+    describe('camelToKebab method', () => {
+        it('should convert camelCase to kebab-case', () => {
+            const kebabString = lib_1.Formatter.camelToKebab('camelCaseString');
+            expect(kebabString).toBe('camel-case-string');
+        });
+        it('should handle spaces and underscores', () => {
+            const kebabString = lib_1.Formatter.camelToKebab('hello World_with Spaces');
+            expect(kebabString).toBe('hello-world_with-spaces');
+        });
+        it('should throw an error for non-string input', () => {
+            expect(() => lib_1.Formatter.camelToKebab(123)).toThrowError('Invalid input. Please provide a valid string.');
+        });
+    });
+    describe('obfuscate method', () => {
+        it('should obfuscate email address', () => {
+            const obfuscatedEmail = lib_1.Formatter.obfuscate('johndoe@email.com');
+            expect(obfuscatedEmail).toMatch(/^jo.*@.*$/);
+        });
+        it('should throw an error for non-string input', () => {
+            //@ts-ignore
+            expect(() => lib_1.Formatter.obfuscate(123)).toThrowError('Provide a valid string');
+        });
+        it('should throw an error for an invalid email address', () => {
+            expect(() => lib_1.Formatter.obfuscate('invalid-email')).toThrowError('Provide a valid email address');
+        });
+    });
+    describe('toUpperTitle method', () => {
+        it('should capitalize first letter of each word and remove non-alphanumeric characters', () => {
+            const upperTitle = lib_1.Formatter.toUpperTitle('this is34354345a---sentence');
+            expect(upperTitle).toBe('This Is A Sentence');
+        });
+        it('should throw an error for non-string input', () => {
+            expect(() => lib_1.Formatter.toUpperTitle(123)).toThrowError('Provide a valid string');
+        });
+        it('should throw an error for empty string', () => {
+            expect(() => lib_1.Formatter.toUpperTitle('')).toThrowError('Provide a valid string');
+        });
+    });
+    describe('slugify method', () => {
+        it('should generate a slug from the given string', () => {
+            const slug = lib_1.Formatter.slugify('Hello World');
+            expect(slug).toBe('hello-world');
+        });
+        it('should handle special characters and spaces', () => {
+            const slug = lib_1.Formatter.slugify('Special Characters % #$ & Space');
+            expect(slug).toBe('special-characters-space');
+        });
+        it('should throw an error for non-string input', () => {
+            expect(() => lib_1.Formatter.slugify(123)).toThrowError('Provide a valid string');
+        });
+    });
+});

package/dist/index.d.ts

@@ -1,2 +1 @@
-export { Crypto } from './lib';
-export { Formatter } from './lib';
+export { Crypto, Formatter, Colorful } from './lib';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Formatter = exports.Crypto = void 0;
+exports.Colorful = exports.Formatter = exports.Crypto = void 0;
 var lib_1 = require("./lib");
 Object.defineProperty(exports, "Crypto", { enumerable: true, get: function () { return lib_1.Crypto; } });
-var lib_2 = require("./lib");
-Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return lib_2.Formatter; } });
+Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return lib_1.Formatter; } });
+Object.defineProperty(exports, "Colorful", { enumerable: true, get: function () { return lib_1.Colorful; } });

package/dist/lib/colorful.d.ts

@@ -0,0 +1,46 @@
+declare class Colorful {
+    /**
+     * @remarks
+     *  Receives a color in RGB format and returns it in HEX format
+     * @param color - Color in RGB format
+     * @example
+     * ```ts
+     * const color = 'rgb(255, 255, 255)';
+     * const hexColor = rgbToHex(color);
+     * console.log(hexColor) // #ffffff
+     * ```
+     *
+     * @returns Color in HEX format string
+     */
+    rgbToHex: (color: string) => string;
+    /**
+     * @remarks
+     *  Receives a color in HEX format and returns it in RGB format
+     * @param hexColor - Color in HEX format
+     * @example
+     * ```ts
+     * const hexColor = '#ffffff';
+     * const rgbColor = hexToRgb(hexColor);
+     * console.log(rgbColor) // 'rgb(255, 255, 255)'
+     * ```
+     *
+     * @returns Color in RGB format string
+     */
+    hexToRgb: (hexColor: string) => string;
+    /**
+     * @remarks
+     *  Checks whether a given HEX color is light or dark
+     * @param hexColor - Color in HEX format
+     * @example
+     * ```ts
+     * const hexColor = '#ffffff';
+     * const isLight = isLightColor(hexColor);
+     * console.log(isLight); // true or false
+     * ```
+     *
+     * @returns True if the color is light, false if it is dark
+     */
+    isLightColor: (color: string) => boolean;
+}
+declare const colorful: Colorful;
+export default colorful;

package/dist/lib/colorful.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+     Author : Mhmd Hammoud https://github.com/mhmdhammoud
+     Date : 2024-01-20
+     Description : Color adapter
+     Version : 1.0
+*/
+class Colorful {
+    constructor() {
+        /**
+         * @remarks
+         *  Receives a color in RGB format and returns it in HEX format
+         * @param color - Color in RGB format
+         * @example
+         * ```ts
+         * const color = 'rgb(255, 255, 255)';
+         * const hexColor = rgbToHex(color);
+         * console.log(hexColor) // #ffffff
+         * ```
+         *
+         * @returns Color in HEX format string
+         */
+        this.rgbToHex = (color) => {
+            const componentToHex = (c) => {
+                const hex = c.toString(16);
+                return hex.length == 1 ? '0' + hex : hex;
+            };
+            const rgbaMatch = color.match(/rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*((\d+\.)?\d+)\)/);
+            const rgbMatch = color.match(/rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)/);
+            let redColor, greenColor, blueColor;
+            if (rgbaMatch) {
+                redColor = parseInt(rgbaMatch[1], 10);
+                greenColor = parseInt(rgbaMatch[2], 10);
+                blueColor = parseInt(rgbaMatch[3], 10);
+            }
+            else if (rgbMatch) {
+                redColor = parseInt(rgbMatch[1], 10);
+                greenColor = parseInt(rgbMatch[2], 10);
+                blueColor = parseInt(rgbMatch[3], 10);
+            }
+            else {
+                // Both patterns failed to match
+                throw new Error(`Invalid color format '${color}'. Please provide a valid RGB or RGBA color.`);
+            }
+            const hexColor = '#' +
+                componentToHex(redColor) +
+                componentToHex(greenColor) +
+                componentToHex(blueColor);
+            return hexColor;
+        };
+        /**
+         * @remarks
+         *  Receives a color in HEX format and returns it in RGB format
+         * @param hexColor - Color in HEX format
+         * @example
+         * ```ts
+         * const hexColor = '#ffffff';
+         * const rgbColor = hexToRgb(hexColor);
+         * console.log(rgbColor) // 'rgb(255, 255, 255)'
+         * ```
+         *
+         * @returns Color in RGB format string
+         */
+        this.hexToRgb = (hexColor) => {
+            const hex = hexColor.replace(/^#/, '');
+            const bigint = parseInt(hex, 16);
+            const red = (bigint >> 16) & 255;
+            const green = (bigint >> 8) & 255;
+            const blue = bigint & 255;
+            return `rgb(${red}, ${green}, ${blue})`;
+        };
+        /**
+         * @remarks
+         *  Checks whether a given HEX color is light or dark
+         * @param hexColor - Color in HEX format
+         * @example
+         * ```ts
+         * const hexColor = '#ffffff';
+         * const isLight = isLightColor(hexColor);
+         * console.log(isLight); // true or false
+         * ```
+         *
+         * @returns True if the color is light, false if it is dark
+         */
+        this.isLightColor = (color) => {
+            // Remove spaces
+            const trimmedColor = color.replace(/\s/g, '');
+            // Check if the color is in RGBA format
+            const rgbaMatch = trimmedColor.match(/^rgba\((\d+),(\d+),(\d+),(\d+(\.\d+)?)\)$/);
+            if (rgbaMatch) {
+                // Extract RGB components from RGBA
+                const r = parseInt(rgbaMatch[1], 10);
+                const g = parseInt(rgbaMatch[2], 10);
+                const b = parseInt(rgbaMatch[3], 10);
+                // Calculate the relative luminance without considering alpha
+                const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+                // You can adjust the threshold to your preference
+                const threshold = 128;
+                // Determine whether the color is light or dark
+                return luminance > threshold;
+            }
+            // Check if the color is in RGB format
+            const rgbMatch = trimmedColor.match(/^rgb\((\d+),(\d+),(\d+)\)$/);
+            if (rgbMatch) {
+                // Extract RGB components from RGB
+                const r = parseInt(rgbMatch[1], 10);
+                const g = parseInt(rgbMatch[2], 10);
+                const b = parseInt(rgbMatch[3], 10);
+                // Calculate the relative luminance of the color
+                // This formula gives more weight to green as the human eye is more sensitive to it
+                const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+                // You can adjust the threshold to your preference
+                const threshold = 128;
+                // Determine whether the color is light or dark
+                return luminance > threshold;
+            }
+            // Remove the '#' character if present
+            const hexColor = trimmedColor.replace('#', '');
+            // Check if the hex color has a valid format
+            if (!/^[0-9A-Fa-f]{6}$/.test(hexColor)) {
+                throw new Error(`Invalid color format '${color}'. Please provide a valid HEX, RGB, or RGBA color.`);
+            }
+            // Convert the hex color to RGB components
+            const r = parseInt(hexColor.slice(0, 2), 16);
+            const g = parseInt(hexColor.slice(2, 4), 16);
+            const b = parseInt(hexColor.slice(4, 6), 16);
+            // Calculate the relative luminance of the color
+            // This formula gives more weight to green as the human eye is more sensitive to it
+            const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+            // You can adjust the threshold to your preference
+            const threshold = 128;
+            // Determine whether the color is light or dark
+            return luminance > threshold;
+        };
+    }
+}
+const colorful = new Colorful();
+exports.default = colorful;

package/dist/lib/formatter.d.ts

@@ -10,14 +10,14 @@ declare class Formatter {
      * // => 'Hello-World'
      * ```
      * */
-    toUpperFirst: (_: string | number, withSpacing?: boolean) => string;
+    toUpperFirst: (str: string | number) => string;
     /**
      * @remarks normalizes input to supported path and file name format.
      * Changes camelCase strings to kebab-case, replaces spaces with dash and keeps underscores. *
      * @param str - String needed to be modified
      * @returns formatted string
      */
-    camelToKebab: (str: string) => string;
+    camelToKebab: (str: string | number) => string;
     /**
      * @remarks obfuscates email address
      * @param email - email address to be obfuscated
@@ -39,7 +39,7 @@ declare class Formatter {
      * console.log(newSentence) // 'This Is A Sentence'
      * ```
      */
-    toUpperTitle: (sentence: string) => string;
+    toUpperTitle: (sentence: string | number) => string;
     /**
      * @remarks Generates a slug from a given string
      * @param title - string to be converted to slug
@@ -49,7 +49,7 @@ declare class Formatter {
      * formatter.slugify('Hello World') // => hello-world
      * ```
      * */
-    slugify: (title: string) => string;
+    slugify: (title: string | number) => string;
 }
 declare const formatter: Formatter;
 export default formatter;

package/dist/lib/formatter.js

@@ -19,26 +19,15 @@ class Formatter {
          * // => 'Hello-World'
          * ```
          * */
-        this.toUpperFirst = (_, withSpacing = true) => {
-            if (typeof _ !== 'string')
+        this.toUpperFirst = (str) => {
+            if (typeof str !== 'string')
                 throw new Error('Provide a valid string');
-            if (withSpacing) {
-                return _.toLowerCase()
-                    .split(' ')
-                    .map((val) => val.charAt(0).toUpperCase() + val.slice(1))
-                    .join(' ')
-                    .replace(/ /g, '-')
-                    .replace(/\//g, '-')
-                    .replace(/\./g, '');
-            }
-            else {
-                return _.toLowerCase()
-                    .split(' ')
-                    .map((val) => val.charAt(0).toUpperCase() + val.slice(1))
-                    .join(' ')
-                    .replace(/\//g, '-')
-                    .replace(/\./g, '');
-            }
+            const formattedString = str
+                .toString()
+                .replace(/[^a-zA-Z0-9]+/g, '-')
+                .trim()
+                .toLowerCase();
+            return formattedString.charAt(0).toUpperCase() + formattedString.slice(1);
         };
         /**
          * @remarks normalizes input to supported path and file name format.
@@ -47,6 +36,9 @@ class Formatter {
          * @returns formatted string
          */
         this.camelToKebab = (str) => {
+            if (typeof str !== 'string') {
+                throw new Error('Invalid input. Please provide a valid string.');
+            }
             const STRING_DASHERIZE_REGEXP = /\s/g;
             const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
             return str
@@ -96,14 +88,11 @@ class Formatter {
                 throw new Error('Provide a valid string');
             if (!sentence)
                 throw new Error('Provide a valid string');
-            const sanitizedSentence = sentence.replace(/[^a-zA-Z0-9]+/g, ' ');
-            const words = sanitizedSentence.split(' ');
-            const capitalizedWords = [];
-            for (let i = 0; i < words.length; i++) {
-                const word = words[i];
-                const capitalizedWord = word.charAt(0).toUpperCase() + word.slice(1);
-                capitalizedWords.push(capitalizedWord);
-            }
+            const sanitizedSentence = sentence.replace(/[^a-zA-Z\s]+/g, ' '); // Exclude numbers from the character class
+            const words = sanitizedSentence.split(/\s+/);
+            const capitalizedWords = words.map((word) => {
+                return word.charAt(0).toUpperCase() + word.slice(1);
+            });
             return capitalizedWords.join(' ');
         };
         /**
@@ -119,28 +108,8 @@ class Formatter {
             if (typeof title !== 'string')
                 throw new Error('Provide a valid string');
             return title
-                .replace(/ /g, '-')
-                .replace(/%/g, '-')
-                .replace(/#/g, '-')
-                .replace(/\?/g, '-')
-                .replace(/,/g, '-')
-                .replace(/\//g, '-')
-                .replace(/\\/g, '-')
-                .replace(/\./g, '')
-                .replace(/'/g, '')
-                .replace(/"/g, '')
-                .replace(/\+/g, '-')
-                .replace(/\*/g, '-')
-                .replace(/\^/g, '-')
-                .replace(/@/g, '-')
-                .replace(/;/g, '-')
-                .replace(/:/g, '-')
-                .replace(/!/g, '-')
-                .replace(/&/g, '-')
-                .replace(/\$/g, '-')
-                .replace(/\(/g, '-')
-                .replace(/\)/g, '-')
-                .trim()
+                .replace(/[^\w\s]/g, '') // Remove non-alphanumeric characters
+                .replace(/\s+/g, '-') // Replace consecutive spaces with a single dash
                 .toLowerCase();
         };
     }

package/dist/lib/imagefull.d.ts

@@ -0,0 +1,23 @@
+declare class ImageFull {
+    /**
+     * @remarks
+     *  Receives either a className or an id or an element and returns a promise that resolves when all images are loaded
+     * @param selector - either a className or an id or an element that contains images
+     * @example
+     * ```ts
+     * .image-container
+     * #image-container
+     * img //as an element
+     *
+     * Imagefull.preloadImages('.image-container').then((event) => {
+     *  do something
+     * })
+     * ```
+     *
+     * @returns Promise<ImagesLoaded | undefined>
+     *
+     */
+    preloadImages: (selector: string) => Promise<unknown>;
+}
+declare const imagefull: ImageFull;
+export default imagefull;

package/dist/lib/imagefull.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const imagesloaded_1 = __importDefault(require("imagesloaded"));
+/*
+     Author : Mustafa Halabi https://github.com/mustafahalabi
+     Date : 2024-01-29
+     Description : Loads images and returns a promise
+     Version : 1.0
+*/
+class ImageFull {
+    constructor() {
+        /**
+         * @remarks
+         *  Receives either a className or an id or an element and returns a promise that resolves when all images are loaded
+         * @param selector - either a className or an id or an element that contains images
+         * @example
+         * ```ts
+         * .image-container
+         * #image-container
+         * img //as an element
+         *
+         * Imagefull.preloadImages('.image-container').then((event) => {
+         *  do something
+         * })
+         * ```
+         *
+         * @returns Promise<ImagesLoaded | undefined>
+         *
+         */
+        this.preloadImages = (selector) => {
+            return new Promise((resolve) => {
+                (0, imagesloaded_1.default)(document.querySelectorAll(selector), { background: true }, (event) => {
+                    resolve(event);
+                });
+            });
+        };
+    }
+}
+const imagefull = new ImageFull();
+exports.default = imagefull;

package/dist/lib/index.d.ts

@@ -1,3 +1,5 @@
 export { default as Crypto } from './cypto';
 export { default as Formatter } from './formatter';
 export { default as Pdf } from './formatter';
+export { default as Colorful } from './colorful';
+export { default as ImageFull } from './imagefull';

package/dist/lib/index.js

@@ -3,10 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pdf = exports.Formatter = exports.Crypto = void 0;
+exports.ImageFull = exports.Colorful = exports.Pdf = exports.Formatter = exports.Crypto = void 0;
 var cypto_1 = require("./cypto");
 Object.defineProperty(exports, "Crypto", { enumerable: true, get: function () { return __importDefault(cypto_1).default; } });
 var formatter_1 = require("./formatter");
 Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return __importDefault(formatter_1).default; } });
 var formatter_2 = require("./formatter");
 Object.defineProperty(exports, "Pdf", { enumerable: true, get: function () { return __importDefault(formatter_2).default; } });
+var colorful_1 = require("./colorful");
+Object.defineProperty(exports, "Colorful", { enumerable: true, get: function () { return __importDefault(colorful_1).default; } });
+var imagefull_1 = require("./imagefull");
+Object.defineProperty(exports, "ImageFull", { enumerable: true, get: function () { return __importDefault(imagefull_1).default; } });

package/imagesloaded.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="jquery" />
+
+declare namespace ImagesLoaded {
+	type ElementSelector = Element | NodeList | Element[] | string
+
+	/** interface for an image currently loading or completed */
+	interface LoadingImage {
+		img: HTMLImageElement
+		isLoaded: boolean
+	}
+
+	interface ImagesLoadedCallback {
+		(instance?: ImagesLoaded): void
+	}
+
+	interface ImagesLoadedListener {
+		(instance: ImagesLoaded, image?: LoadingImage): void
+	}
+
+	interface ImagesLoaded {
+		new (elem: ElementSelector, callback: ImagesLoadedCallback): ImagesLoaded
+
+		images: LoadingImage[]
+
+		// event listeners
+		on(event: string, listener: ImagesLoadedListener): void
+		off(event: string, listener: ImagesLoadedListener): void
+		once(event: string, listener: ImagesLoadedListener): void
+		progressedCount: number | undefined
+	}
+
+	interface ImagesLoadedOptions {
+		background: true | string
+	}
+
+	interface ImagesLoadedConstructor {
+		/**
+		 * Creates a new ImagesLoaded object with the provided callback
+		 * @param elem Element, NodeList, Element array, or selector string for images to watch
+		 * @param options object that can tell imagesloaded to watch background images as well
+		 * @param callback function triggered after all images have been loaded
+		 */
+		(
+			elem: ElementSelector,
+			options: ImagesLoadedOptions,
+			callback?: ImagesLoadedCallback
+		): ImagesLoaded
+		(elem: ElementSelector, callback?: ImagesLoadedCallback): ImagesLoaded
+	}
+}
+
+declare var imagesLoaded: ImagesLoaded.ImagesLoadedConstructor
+
+declare module 'imagesloaded' {
+	export = imagesLoaded
+}
+
+interface JQuery {
+	imagesLoaded(
+		callback?: ImagesLoaded.ImagesLoadedCallback
+	): JQueryDeferred<ImagesLoaded.ImagesLoaded>
+	imagesLoaded(
+		options: ImagesLoaded.ImagesLoadedOptions,
+		callback?: ImagesLoaded.ImagesLoadedCallback
+	): JQueryDeferred<ImagesLoaded.ImagesLoaded>
+}

package/jest.config.js

@@ -0,0 +1,13 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+	preset: 'ts-jest',
+	testEnvironment: 'node',
+	coverageDirectory: 'coverage',
+	coverageProvider: 'v8',
+	collectCoverageFrom: ['src/**/*.ts', '!test/**/*.ts'],
+	transform: {
+		'^.+\\.(ts)$': 'ts-jest',
+	},
+	transformIgnorePatterns: [],
+	testMatch: ['<rootDir>/src/**/__tests__/**/*.test.ts'],
+}

package/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "@mhmdhammoud/meritt-utils",
-	"version": "1.0.6",
+	"version": "1.2.0",
 	"description": "",
 	"main": "./dist/index.js",
 	"private": false,
+	"typings": "./dist/index.d.ts",
 	"repository": {
 		"type": "git",
 		"url": "git@github.com:Mhmdhammoud/meritt-utils.git"
@@ -19,21 +20,26 @@
 		"types": "tsc --noemit",
 		"prepare": "husky install",
 		"lint": "eslint src --fix",
-		"prepublish": "npm run build"
+		"prepublish": "npm run build",
+		"test": "jest",
+		"test:coverage": "jest --coverage"
 	},
 	"devDependencies": {
-		"@types/jest": "^27.5.1",
+		"@types/jest": "^27.5.2",
 		"@typescript-eslint/eslint-plugin": "^5.17.0",
 		"@typescript-eslint/parser": "^5.17.0",
 		"eslint": "^8.12.0",
 		"eslint-plugin-tsdoc": "^0.2.14",
 		"husky": "^8.0.0",
+		"jest": "^29.7.0",
+		"ts-jest": "^29.1.1",
 		"ts-node-dev": "^1.1.8",
 		"typescript": "^4.6.3"
 	},
 	"author": "Mhmdhammoud",
 	"license": "ISC",
 	"dependencies": {
-		"axios": "^1.4.0"
+		"axios": "^1.4.0",
+		"imagesloaded": "^5.0.0"
 	}
 }

package/src/__tests__/colorful.test.ts

@@ -0,0 +1,77 @@
+import {Colorful} from '../lib'
+
+describe('Colorful Class', () => {
+	describe('rgbToHex method', () => {
+		it('should convert RGB to HEX', () => {
+			const rgbColor = 'rgb(255, 255, 255)'
+			const hexColor = Colorful.rgbToHex(rgbColor)
+			expect(hexColor).toBe('#ffffff')
+		})
+
+		it('should convert RGBA to HEX', () => {
+			const rgbaColor = 'rgba(255, 0, 0, 0.5)'
+			const hexColor = Colorful.rgbToHex(rgbaColor)
+			expect(hexColor).toBe('#ff0000')
+		})
+
+		it('should throw an error for invalid color format', () => {
+			const invalidColor = 'invalidColor'
+			expect(() => Colorful.rgbToHex(invalidColor)).toThrowError(
+				`Invalid color format '${invalidColor}'. Please provide a valid RGB or RGBA color.`
+			)
+		})
+	})
+
+	describe('hexToRgb method', () => {
+		it('should convert HEX to RGB', () => {
+			const hexColor = '#ffffff'
+			const rgbColor = Colorful.hexToRgb(hexColor)
+			expect(rgbColor).toBe('rgb(255, 255, 255)')
+		})
+	})
+
+	describe('isLightColor method', () => {
+		it('should return true for a light color (HEX format)', () => {
+			const lightHexColor = '#f0f0f0'
+			const isLight = Colorful.isLightColor(lightHexColor)
+			expect(isLight).toBe(true)
+		})
+
+		it('should return false for a dark color (HEX format)', () => {
+			const darkHexColor = '#333333'
+			const isLight = Colorful.isLightColor(darkHexColor)
+			expect(isLight).toBe(false)
+		})
+
+		it('should return true for a light color (RGBA format)', () => {
+			const lightRgbaColor = 'rgba(255, 255, 255, 0.5)'
+			const isLight = Colorful.isLightColor(lightRgbaColor)
+			expect(isLight).toBe(true)
+		})
+
+		it('should return false for a dark color (RGBA format)', () => {
+			const darkRgbaColor = 'rgba(0, 0, 0, 0.8)'
+			const isLight = Colorful.isLightColor(darkRgbaColor)
+			expect(isLight).toBe(false)
+		})
+
+		it('should return true for a light color (RGB format)', () => {
+			const lightRgbColor = 'rgb(200, 220, 255)'
+			const isLight = Colorful.isLightColor(lightRgbColor)
+			expect(isLight).toBe(true)
+		})
+
+		it('should return false for a dark color (RGB format)', () => {
+			const darkRgbColor = 'rgb(10, 20, 30)'
+			const isLight = Colorful.isLightColor(darkRgbColor)
+			expect(isLight).toBe(false)
+		})
+
+		it('should throw an error for an invalid color format', () => {
+			const invalidColor = 'invalid-color'
+			expect(() => Colorful.isLightColor(invalidColor)).toThrowError(
+				"Invalid color format 'invalid-color'. Please provide a valid HEX, RGB, or RGBA color."
+			)
+		})
+	})
+})

package/src/__tests__/formatter.test.ts

@@ -0,0 +1,96 @@
+import {Formatter} from '../lib'
+
+describe('Formatter', () => {
+	describe('toUpperFirst method', () => {
+		it('should format string with - and upper first letter', () => {
+			const formattedString = Formatter.toUpperFirst('hello world')
+			expect(formattedString).toBe('Hello-world')
+		})
+
+		it('should format string with spaces and upper first letter of every word', () => {
+			const formattedString = Formatter.toUpperFirst('hello_world+test')
+			expect(formattedString).toBe('Hello-world-test')
+		})
+
+		it('should throw an error for non-string input', () => {
+			expect(() => Formatter.toUpperFirst(123)).toThrowError(
+				'Provide a valid string'
+			)
+		})
+	})
+
+	describe('camelToKebab method', () => {
+		it('should convert camelCase to kebab-case', () => {
+			const kebabString = Formatter.camelToKebab('camelCaseString')
+			expect(kebabString).toBe('camel-case-string')
+		})
+
+		it('should handle spaces and underscores', () => {
+			const kebabString = Formatter.camelToKebab('hello World_with Spaces')
+			expect(kebabString).toBe('hello-world_with-spaces')
+		})
+
+		it('should throw an error for non-string input', () => {
+			expect(() => Formatter.camelToKebab(123)).toThrowError(
+				'Invalid input. Please provide a valid string.'
+			)
+		})
+	})
+
+	describe('obfuscate method', () => {
+		it('should obfuscate email address', () => {
+			const obfuscatedEmail = Formatter.obfuscate('johndoe@email.com')
+			expect(obfuscatedEmail).toMatch(/^jo.*@.*$/)
+		})
+
+		it('should throw an error for non-string input', () => {
+			//@ts-ignore
+			expect(() => Formatter.obfuscate(123)).toThrowError(
+				'Provide a valid string'
+			)
+		})
+
+		it('should throw an error for an invalid email address', () => {
+			expect(() => Formatter.obfuscate('invalid-email')).toThrowError(
+				'Provide a valid email address'
+			)
+		})
+	})
+
+	describe('toUpperTitle method', () => {
+		it('should capitalize first letter of each word and remove non-alphanumeric characters', () => {
+			const upperTitle = Formatter.toUpperTitle('this is34354345a---sentence')
+			expect(upperTitle).toBe('This Is A Sentence')
+		})
+
+		it('should throw an error for non-string input', () => {
+			expect(() => Formatter.toUpperTitle(123)).toThrowError(
+				'Provide a valid string'
+			)
+		})
+
+		it('should throw an error for empty string', () => {
+			expect(() => Formatter.toUpperTitle('')).toThrowError(
+				'Provide a valid string'
+			)
+		})
+	})
+
+	describe('slugify method', () => {
+		it('should generate a slug from the given string', () => {
+			const slug = Formatter.slugify('Hello World')
+			expect(slug).toBe('hello-world')
+		})
+
+		it('should handle special characters and spaces', () => {
+			const slug = Formatter.slugify('Special Characters % #$ & Space')
+			expect(slug).toBe('special-characters-space')
+		})
+
+		it('should throw an error for non-string input', () => {
+			expect(() => Formatter.slugify(123)).toThrowError(
+				'Provide a valid string'
+			)
+		})
+	})
+})

package/src/index.ts

@@ -1,2 +1 @@
-export {Crypto} from './lib'
-export {Formatter} from './lib'
+export {Crypto, Formatter, Colorful} from './lib'

package/src/lib/colorful.ts

@@ -0,0 +1,167 @@
+/*
+	 Author : Mhmd Hammoud https://github.com/mhmdhammoud
+	 Date : 2024-01-20
+	 Description : Color adapter
+	 Version : 1.0
+*/
+class Colorful {
+	/**
+	 * @remarks
+	 *  Receives a color in RGB format and returns it in HEX format
+	 * @param color - Color in RGB format
+	 * @example
+	 * ```ts
+	 * const color = 'rgb(255, 255, 255)';
+	 * const hexColor = rgbToHex(color);
+	 * console.log(hexColor) // #ffffff
+	 * ```
+	 *
+	 * @returns Color in HEX format string
+	 */
+	rgbToHex = (color: string): string => {
+		const componentToHex = (c: any) => {
+			const hex = c.toString(16)
+			return hex.length == 1 ? '0' + hex : hex
+		}
+
+		const rgbaMatch = color.match(
+			/rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*((\d+\.)?\d+)\)/
+		)
+		const rgbMatch = color.match(/rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)/)
+
+		let redColor, greenColor, blueColor
+
+		if (rgbaMatch) {
+			redColor = parseInt(rgbaMatch[1], 10)
+			greenColor = parseInt(rgbaMatch[2], 10)
+			blueColor = parseInt(rgbaMatch[3], 10)
+		} else if (rgbMatch) {
+			redColor = parseInt(rgbMatch[1], 10)
+			greenColor = parseInt(rgbMatch[2], 10)
+			blueColor = parseInt(rgbMatch[3], 10)
+		} else {
+			// Both patterns failed to match
+			throw new Error(
+				`Invalid color format '${color}'. Please provide a valid RGB or RGBA color.`
+			)
+		}
+
+		const hexColor =
+			'#' +
+			componentToHex(redColor) +
+			componentToHex(greenColor) +
+			componentToHex(blueColor)
+
+		return hexColor
+	}
+
+	/**
+	 * @remarks
+	 *  Receives a color in HEX format and returns it in RGB format
+	 * @param hexColor - Color in HEX format
+	 * @example
+	 * ```ts
+	 * const hexColor = '#ffffff';
+	 * const rgbColor = hexToRgb(hexColor);
+	 * console.log(rgbColor) // 'rgb(255, 255, 255)'
+	 * ```
+	 *
+	 * @returns Color in RGB format string
+	 */
+	hexToRgb = (hexColor: string): string => {
+		const hex = hexColor.replace(/^#/, '')
+		const bigint = parseInt(hex, 16)
+		const red = (bigint >> 16) & 255
+		const green = (bigint >> 8) & 255
+		const blue = bigint & 255
+		return `rgb(${red}, ${green}, ${blue})`
+	}
+
+	/**
+	 * @remarks
+	 *  Checks whether a given HEX color is light or dark
+	 * @param hexColor - Color in HEX format
+	 * @example
+	 * ```ts
+	 * const hexColor = '#ffffff';
+	 * const isLight = isLightColor(hexColor);
+	 * console.log(isLight); // true or false
+	 * ```
+	 *
+	 * @returns True if the color is light, false if it is dark
+	 */
+	isLightColor = (color: string): boolean => {
+		// Remove spaces
+		const trimmedColor = color.replace(/\s/g, '')
+
+		// Check if the color is in RGBA format
+		const rgbaMatch = trimmedColor.match(
+			/^rgba\((\d+),(\d+),(\d+),(\d+(\.\d+)?)\)$/
+		)
+
+		if (rgbaMatch) {
+			// Extract RGB components from RGBA
+			const r = parseInt(rgbaMatch[1], 10)
+			const g = parseInt(rgbaMatch[2], 10)
+			const b = parseInt(rgbaMatch[3], 10)
+
+			// Calculate the relative luminance without considering alpha
+			const luminance = 0.299 * r + 0.587 * g + 0.114 * b
+
+			// You can adjust the threshold to your preference
+			const threshold = 128
+
+			// Determine whether the color is light or dark
+			return luminance > threshold
+		}
+
+		// Check if the color is in RGB format
+		const rgbMatch = trimmedColor.match(/^rgb\((\d+),(\d+),(\d+)\)$/)
+
+		if (rgbMatch) {
+			// Extract RGB components from RGB
+			const r = parseInt(rgbMatch[1], 10)
+			const g = parseInt(rgbMatch[2], 10)
+			const b = parseInt(rgbMatch[3], 10)
+
+			// Calculate the relative luminance of the color
+			// This formula gives more weight to green as the human eye is more sensitive to it
+			const luminance = 0.299 * r + 0.587 * g + 0.114 * b
+
+			// You can adjust the threshold to your preference
+			const threshold = 128
+
+			// Determine whether the color is light or dark
+			return luminance > threshold
+		}
+
+		// Remove the '#' character if present
+		const hexColor = trimmedColor.replace('#', '')
+
+		// Check if the hex color has a valid format
+		if (!/^[0-9A-Fa-f]{6}$/.test(hexColor)) {
+			throw new Error(
+				`Invalid color format '${color}'. Please provide a valid HEX, RGB, or RGBA color.`
+			)
+		}
+
+		// Convert the hex color to RGB components
+		const r = parseInt(hexColor.slice(0, 2), 16)
+		const g = parseInt(hexColor.slice(2, 4), 16)
+		const b = parseInt(hexColor.slice(4, 6), 16)
+
+		// Calculate the relative luminance of the color
+		// This formula gives more weight to green as the human eye is more sensitive to it
+		const luminance = 0.299 * r + 0.587 * g + 0.114 * b
+
+		// You can adjust the threshold to your preference
+		const threshold = 128
+
+		// Determine whether the color is light or dark
+		return luminance > threshold
+	}
+}
+
+const colorful = new Colorful()
+
+export default colorful

package/src/lib/formatter.ts

@@ -16,24 +16,16 @@ class Formatter {
 	 * // => 'Hello-World'
 	 * ```
 	 * */
-	toUpperFirst = (_: string | number, withSpacing = true): string => {
-		if (typeof _ !== 'string') throw new Error('Provide a valid string')
-		if (withSpacing) {
-			return _.toLowerCase()
-				.split(' ')
-				.map((val: string) => val.charAt(0).toUpperCase() + val.slice(1))
-				.join(' ')
-				.replace(/ /g, '-')
-				.replace(/\//g, '-')
-				.replace(/\./g, '')
-		} else {
-			return _.toLowerCase()
-				.split(' ')
-				.map((val: string) => val.charAt(0).toUpperCase() + val.slice(1))
-				.join(' ')
-				.replace(/\//g, '-')
-				.replace(/\./g, '')
-		}
+	toUpperFirst = (str: string | number): string => {
+		if (typeof str !== 'string') throw new Error('Provide a valid string')
+
+		const formattedString = str
+			.toString()
+			.replace(/[^a-zA-Z0-9]+/g, '-')
+			.trim()
+			.toLowerCase()
+
+		return formattedString.charAt(0).toUpperCase() + formattedString.slice(1)
 	}
 
 	/**
@@ -42,9 +34,14 @@ class Formatter {
 	 * @param str - String needed to be modified
 	 * @returns formatted string
 	 */
-	camelToKebab = (str: string) => {
+	camelToKebab = (str: string | number): string => {
+		if (typeof str !== 'string') {
+			throw new Error('Invalid input. Please provide a valid string.')
+		}
+
 		const STRING_DASHERIZE_REGEXP = /\s/g
 		const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g
+
 		return str
 			.replace(STRING_DECAMELIZE_REGEXP, '$1-$2')
 			.toLowerCase()
@@ -92,19 +89,15 @@ class Formatter {
 	 * console.log(newSentence) // 'This Is A Sentence'
 	 * ```
 	 */
-	toUpperTitle = (sentence: string): string => {
+	toUpperTitle = (sentence: string | number): string => {
 		if (typeof sentence !== 'string') throw new Error('Provide a valid string')
 		if (!sentence) throw new Error('Provide a valid string')
 
-		const sanitizedSentence = sentence.replace(/[^a-zA-Z0-9]+/g, ' ')
-		const words = sanitizedSentence.split(' ')
-		const capitalizedWords = []
-
-		for (let i = 0; i < words.length; i++) {
-			const word = words[i]
-			const capitalizedWord = word.charAt(0).toUpperCase() + word.slice(1)
-			capitalizedWords.push(capitalizedWord)
-		}
+		const sanitizedSentence = sentence.replace(/[^a-zA-Z\s]+/g, ' ') // Exclude numbers from the character class
+		const words = sanitizedSentence.split(/\s+/)
+		const capitalizedWords = words.map((word) => {
+			return word.charAt(0).toUpperCase() + word.slice(1)
+		})
 
 		return capitalizedWords.join(' ')
 	}
@@ -118,31 +111,12 @@ class Formatter {
 	 * formatter.slugify('Hello World') // => hello-world
 	 * ```
 	 * */
-	slugify = (title: string) => {
+	slugify = (title: string | number): string => {
 		if (typeof title !== 'string') throw new Error('Provide a valid string')
+
 		return title
-			.replace(/ /g, '-')
-			.replace(/%/g, '-')
-			.replace(/#/g, '-')
-			.replace(/\?/g, '-')
-			.replace(/,/g, '-')
-			.replace(/\//g, '-')
-			.replace(/\\/g, '-')
-			.replace(/\./g, '')
-			.replace(/'/g, '')
-			.replace(/"/g, '')
-			.replace(/\+/g, '-')
-			.replace(/\*/g, '-')
-			.replace(/\^/g, '-')
-			.replace(/@/g, '-')
-			.replace(/;/g, '-')
-			.replace(/:/g, '-')
-			.replace(/!/g, '-')
-			.replace(/&/g, '-')
-			.replace(/\$/g, '-')
-			.replace(/\(/g, '-')
-			.replace(/\)/g, '-')
-			.trim()
+			.replace(/[^\w\s]/g, '') // Remove non-alphanumeric characters
+			.replace(/\s+/g, '-') // Replace consecutive spaces with a single dash
 			.toLowerCase()
 	}
 }

package/src/lib/imagefull.ts

@@ -0,0 +1,41 @@
+import imagesLoaded from 'imagesloaded'
+/*
+	 Author : Mustafa Halabi https://github.com/mustafahalabi
+	 Date : 2024-01-29
+	 Description : Loads images and returns a promise
+	 Version : 1.0
+*/
+class ImageFull {
+	/**
+	 * @remarks
+	 *  Receives either a className or an id or an element and returns a promise that resolves when all images are loaded
+	 * @param selector - either a className or an id or an element that contains images
+	 * @example
+	 * ```ts
+	 * .image-container
+	 * #image-container
+	 * img //as an element
+	 *
+	 * Imagefull.preloadImages('.image-container').then((event) => {
+	 *  do something
+	 * })
+	 * ```
+	 *
+	 * @returns Promise<ImagesLoaded | undefined>
+	 *
+	 */
+	preloadImages = (selector: string) => {
+		return new Promise((resolve) => {
+			imagesLoaded(
+				document.querySelectorAll(selector),
+				{background: true},
+				(event) => {
+					resolve(event)
+				}
+			)
+		})
+	}
+}
+
+const imagefull = new ImageFull()
+export default imagefull

package/src/lib/index.ts

@@ -1,3 +1,5 @@
 export {default as Crypto} from './cypto'
 export {default as Formatter} from './formatter'
 export {default as Pdf} from './formatter'
+export {default as Colorful} from './colorful'
+export {default as ImageFull} from './imagefull'