@mhmdhammoud/meritt-utils 1.0.2 → 1.0.3

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,28 @@
+name: NPM Publish on Release
+
+on:
+  push:
+    branches: [master]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/.github/workflows/push.yml

@@ -0,0 +1,29 @@
+name: Changes
+on:
+  push:
+    branches: [dev]
+jobs:
+  type-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm run types
+  notify:
+    needs: [type-check]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify by Email
+        uses: dawidd6/action-send-mail@v2
+        with:
+          server_address: ${{ secrets.EMAIL_HOST }}
+          server_port: 465
+          username: ${{ secrets.EMAIL_USERNAME }}
+          password: ${{ secrets.EMAIL_PASSWORD }}
+          subject: ${{ github.event.head_commit.message }} ${{ github.job }} job of ${{ github.repository }} has ${{ job.status }}
+          body: ${{ github.job }} job in worflow ${{ github.workflow }} of ${{ github.repository }} has ${{ job.status }}
+          to: mohammad.hammoud.lb@hotmail.com,steef12009@gmail.com,sawwas.omar@gmail.com
+          from: Github Action

package/.husky/pre-commit

@@ -0,0 +1,62 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+red='\033[0;31m'
+green='\033[0;32m'
+yellow='\033[0;33m'
+blue='\033[0;34m'
+magenta='\033[0;35m'
+cyan='\033[0;36m'
+clear='\033[0m'
+echo "
+
+  __  __ ______ _____  _____ _______ _______    _____  ________      __
+ |  \/  |  ____|  __ \|_   _|__   __|__   __|  |  __ \|  ____\ \    / /
+ | \  / | |__  | |__) | | |    | |     | |     | |  | | |__   \ \  / /
+ | |\/| |  __| |  _  /  | |    | |     | |     | |  | |  __|   \ \/ /
+ | |  | | |____| | \ \ _| |_   | |     | |     | |__| | |____   \  /
+ |_|  |_|______|_|  \_\_____|  |_|     |_|     |_____/|______|   \/
+
+
+"
+echo -e "Let's hope you are not ${red}DUMB${clear}!"
+
+echo -ne '\n'
+
+echo -e "${yellow}Or Are You ??${clear}!"
+echo -ne '\n'
+echo -e "${yellow}Running pre-commit hook...${clear}"
+echo -ne '\n'
+echo -ne '\n'
+
+echo -ne '#####################                                                    (25%)\r'
+sleep 0.3
+echo -ne '##############################                                          (35%)\r'
+sleep 0.3
+echo -ne '######################################                                  (45%)\r'
+sleep 0.3
+echo -ne '############################################################            (77%)\r'
+sleep 0.3
+echo -ne '##################################################################     (100%)\r'
+
+echo -ne '\n'
+echo -ne '\n'
+echo -ne '\n'
+
+echo -e "${yellow}Running types...${clear}"
+echo -ne '\n'
+npm run types
+echo -ne '\n'
+
+echo -e "${green}types passed...${clear} ✅"
+echo -ne '\n'
+echo -e "${yellow}Running linting...${clear}"
+
+npm run lint
+echo -e "${green}linting passed...${clear} ✅"
+
+echo -ne '\n'
+
+echo -e "${yellow}Seems like you are a${clear} ${green}CLEVER DEVELOPER${clear} 👌"
+echo -ne '\n'
+echo -e "${green}GOOD TO GO${clear} 🚀🚀🚀"

package/README.md

@@ -19,9 +19,13 @@ yarn add @mhmdhammoud/meritt-utils
 ## Usage
 
 ```typescript
-import {Crypto} from '@mhmdhammoud/meritt-utils'
+// Import the classes you need
+import {Crypto, Formatter} from '@mhmdhammoud/meritt-utils'
 
-// Example of getting all Crypto methods
-const encryptedMessage = Crypto.encrypt('Hello World', 7)
-const decryptedMessage = Crypto.decrypt(encryptedMessage, 7)
+// Example of creating a product slug
+const slug = Formatter.slugify('My Product Name') // my-product-name
+
+// Example of encrypting and decrypting a string
+
+const encryptedMessage = Crypto.encrypt('Hello World', 7) // [23,235,141,414]
 ```

package/ReleaseNotes.md

@@ -0,0 +1,34 @@
+# Changes
+
+## Version 1.0.3
+
+### Added
+
+- Added Formatter class for manipulating strings
+
+```typescript
+import {Formatter} from '@mhmdhammoud/meritt-utils'
+
+// Example of creating a product slug
+const slug = Formatter.slugify('My Product Name') // my-product-name
+```
+
+### Fixes and Improvements
+
+- Fixed bug in Crypto class where encrypting a string with a key that is not a number would throw an error
+
+- Improved Crypto class to allow encrypting and decrypting numbers and objects
+
+- Documented Crypto class
+
+## Version 1.0.2
+
+- Added Crypto class that contains encrypt and decrypt methods for strings, numbers, and objects using a public and private key
+
+```typescript
+import {Crypto} from '@mhmdhammoud/meritt-utils'
+
+// Example of encrypting and decrypting a string
+const encryptedMessage = Crypto.encrypt('Hello World', 7) // [23,235,141,414]
+const decryptedMessage = Crypto.decrypt(encryptedMessage, 247) // Hello World
+```

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Crypto = void 0;
+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; } });

package/dist/lib/cypto.d.ts

@@ -1,19 +1,11 @@
-/**
- * The Crypto class
- * @class Crypto
- * @example
- * ```typescript
- * import crypto from './lib/crypto'
- * ```
- * */
 declare class Crypto {
     private _primeNumberP;
     private _primeNumberQ;
     private _moduloDenominator;
     /**
      * Set the P prime number for the RSA algorithm
-     * @param {string} primeP - The prime number P
-     * @memberof Crypto
+     * @param primeP - The prime number P of type string
+     * @returns void
      * @example
      * ```typescript
      * crypto.setPrimeP(17)
@@ -22,8 +14,8 @@ declare class Crypto {
     setPrimeP(primeP: number): void;
     /**
      * Set the Q prime number for the RSA algorithm
-     * @param {string} primeQ - The prime number Q
-     * @memberof Crypto
+     * @param primeQ - The prime number Q of type string
+     * @returns void
      * @example
      * ```typescript
      * crypto.setPrimeQ(19)
@@ -32,9 +24,9 @@ declare class Crypto {
     setPrimeQ(primeQ: number): void;
     /**
      *
-     * @param {string} base - The base number
-     * @param {string} exponent - The exponent number
-     * @memberof Crypto
+     * @param base - The base number of type number
+     * @param exponent - The exponent number of type number
+     * @returns The modular exponentiation of the base and the exponent
      * @example
      * ```typescript
      * this.modularExponentiation(2, 3)
@@ -43,20 +35,20 @@ declare class Crypto {
     private _modularExponentiation;
     /**
      * Encrypt the message using the public key
-     * @param {string} message - The message to encrypt
-     * @param {string} publicKey - The public key
-     * @memberof Crypto
+     * @param message - The message to encrypt of type string|number|Record
+     * @param publicKey - The public key to encrypt the message with of type number
+     * @returns The encrypted message of type number[]
      * @example
      * ```typescript
      * crypto.encrypt('Hello World', 7)
      * ```
      * */
-    encrypt: (message: string, publicKey: number) => number[];
+    encrypt: (message: string | number | Record<any, any>, publicKey: number) => number[];
     /**
      * Decrypt the message using the private key
-     * @param {string} encryptedMessage - The ciphertext to decrypt
-     * @param {string} privateKey - The private key
-     * @memberof Crypto
+     * @param encryptedMessage - The encryptedMessage to decrypt of type number[]
+     * @param privateKey - The private key to decrypt the message with of type number
+     * @returns The decrypted message of type string
      * @example
      * ```typescript
      * crypto.decrypt([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], 23)

package/dist/lib/cypto.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * The Crypto class
- * @class Crypto
- * @example
- * ```typescript
- * import crypto from './lib/crypto'
- * ```
- * */
+/*
+     Author : Omar Sawwas
+     Date : 2023-06-17
+     Description : RSA algorithm
+     Version : 1.0
+*/
 class Crypto {
     constructor() {
         // Default variables
@@ -16,15 +14,18 @@ class Crypto {
         this._moduloDenominator = this._primeNumberP * this._primeNumberQ;
         /**
          *
-         * @param {string} base - The base number
-         * @param {string} exponent - The exponent number
-         * @memberof Crypto
+         * @param base - The base number of type number
+         * @param exponent - The exponent number of type number
+         * @returns The modular exponentiation of the base and the exponent
          * @example
          * ```typescript
          * this.modularExponentiation(2, 3)
          * ```
          * */
         this._modularExponentiation = (base, exponent) => {
+            if (isNaN(base) || isNaN(exponent)) {
+                throw new Error('Provide a valid number');
+            }
             if (this._moduloDenominator === 1) {
                 return 0;
             }
@@ -41,33 +42,52 @@ class Crypto {
         };
         /**
          * Encrypt the message using the public key
-         * @param {string} message - The message to encrypt
-         * @param {string} publicKey - The public key
-         * @memberof Crypto
+         * @param message - The message to encrypt of type string|number|Record
+         * @param publicKey - The public key to encrypt the message with of type number
+         * @returns The encrypted message of type number[]
          * @example
          * ```typescript
          * crypto.encrypt('Hello World', 7)
          * ```
          * */
         this.encrypt = (message, publicKey) => {
-            const b = [];
+            if (isNaN(publicKey)) {
+                throw new Error('Public key should be a number');
+            }
+            if (typeof message === 'number') {
+                message = message.toString();
+            }
+            if (typeof message === 'object') {
+                message = JSON.stringify(message);
+            }
+            const encryptedMessage = [];
             for (let i = 0; i < message.length; i++) {
                 const a = message.charCodeAt(i);
-                b.push(this._modularExponentiation(a, publicKey));
+                encryptedMessage.push(this._modularExponentiation(a, publicKey));
             }
-            return b;
+            return encryptedMessage;
         };
         /**
          * Decrypt the message using the private key
-         * @param {string} encryptedMessage - The ciphertext to decrypt
-         * @param {string} privateKey - The private key
-         * @memberof Crypto
+         * @param encryptedMessage - The encryptedMessage to decrypt of type number[]
+         * @param privateKey - The private key to decrypt the message with of type number
+         * @returns The decrypted message of type string
          * @example
          * ```typescript
          * crypto.decrypt([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], 23)
          * ```
          * */
         this.decrypt = (encryptedMessage, privateKey) => {
+            if (isNaN(privateKey)) {
+                throw new Error('Private key should be a number');
+            }
+            if (!Array.isArray(encryptedMessage)) {
+                throw new Error('Encrypted message should be an array');
+            }
+            const allValidNumbers = encryptedMessage.every((number) => !isNaN(number));
+            if (!allValidNumbers) {
+                throw new Error('Encrypted message should be an array of numbers');
+            }
             const decryptedAsciiMessage = [];
             for (let i = 0; i < encryptedMessage.length; i++) {
                 const a = encryptedMessage[i];
@@ -82,14 +102,17 @@ class Crypto {
     }
     /**
      * Set the P prime number for the RSA algorithm
-     * @param {string} primeP - The prime number P
-     * @memberof Crypto
+     * @param primeP - The prime number P of type string
+     * @returns void
      * @example
      * ```typescript
      * crypto.setPrimeP(17)
      * ```
      * */
     setPrimeP(primeP) {
+        if (isNaN(primeP)) {
+            throw new Error('Provide a valid number');
+        }
         let isPrime = true;
         for (let i = 2; i < primeP; i++) {
             if (primeP % i === 0) {
@@ -104,14 +127,17 @@ class Crypto {
     }
     /**
      * Set the Q prime number for the RSA algorithm
-     * @param {string} primeQ - The prime number Q
-     * @memberof Crypto
+     * @param primeQ - The prime number Q of type string
+     * @returns void
      * @example
      * ```typescript
      * crypto.setPrimeQ(19)
      * ```
      * */
     setPrimeQ(primeQ) {
+        if (isNaN(primeQ)) {
+            throw new Error('Provide a valid number');
+        }
         let isPrime = true;
         for (let i = 2; i < primeQ; i++) {
             if (primeQ % i === 0) {

package/dist/lib/formatter.d.ts

@@ -0,0 +1,43 @@
+declare class Formatter {
+    /**
+     * @remarks Normalizes input by removing underscores and hyphens and capitalizing the first letter of the sentence.
+     * @param stringToBeChanged - to be formatted without underscores and hyphens
+     * @param withWhiteSpacing - Determines if white spacing is needed in the final string or not (default: true)
+     * @returns string
+     * @example
+     * ```typescript
+     * formatter.toUpperFirst('hello world')
+     * // => 'Hello-World'
+     * ```
+     * */
+    toUpperFirst: (_: string | number, withSpacing?: boolean) => 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;
+    /**
+     * @remarks obfuscates email address
+     * @param email - email address to be obfuscated
+     * @returns obfuscated email address
+     * @example
+     * ```typescript
+     * formatter.obfuscate('johndoe@email.com') // => jo*****@gmail.com
+     * ```
+     * */
+    obfuscate: (email: string) => string;
+    /**
+     * @remarks Generates a slug from a given string
+     * @param title - string to be converted to slug
+     * @returns slug
+     * @example
+     * ```typescript
+     * formatter.slugify('Hello World') // => hello-world
+     * ```
+     * */
+    slugify: (title: string) => string;
+}
+declare const formatter: Formatter;
+export default formatter;

package/dist/lib/formatter.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+     Author : Mhmd Hammoud
+     Date : 2023-06-17
+     Description : String manipulation
+     Version : 1.0
+*/
+class Formatter {
+    constructor() {
+        /**
+         * @remarks Normalizes input by removing underscores and hyphens and capitalizing the first letter of the sentence.
+         * @param stringToBeChanged - to be formatted without underscores and hyphens
+         * @param withWhiteSpacing - Determines if white spacing is needed in the final string or not (default: true)
+         * @returns string
+         * @example
+         * ```typescript
+         * formatter.toUpperFirst('hello world')
+         * // => 'Hello-World'
+         * ```
+         * */
+        this.toUpperFirst = (_, withSpacing = true) => {
+            if (typeof _ !== 'string')
+                throw new Error('Provide a valid string');
+            if (withSpacing) {
+                return _.split(' ')
+                    .map((val) => val.charAt(0).toUpperCase() + val.slice(1))
+                    .join(' ')
+                    .replace(/ /g, '-')
+                    .replace(/\//g, '-')
+                    .replace(/\./g, '');
+            }
+            else {
+                return _.split(' ')
+                    .map((val) => val.charAt(0).toUpperCase() + val.slice(1))
+                    .join(' ')
+                    .replace(/\//g, '-')
+                    .replace(/\./g, '');
+            }
+        };
+        /**
+         * @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
+         */
+        this.camelToKebab = (str) => {
+            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()
+                .replace(STRING_DASHERIZE_REGEXP, '-');
+        };
+        /**
+         * @remarks obfuscates email address
+         * @param email - email address to be obfuscated
+         * @returns obfuscated email address
+         * @example
+         * ```typescript
+         * formatter.obfuscate('johndoe@email.com') // => jo*****@gmail.com
+         * ```
+         * */
+        this.obfuscate = (email) => {
+            if (typeof email !== 'string')
+                throw new Error('Provide a valid string');
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(email))
+                throw new Error('Provide a valid email address');
+            const separatorIndex = email.indexOf('@');
+            if (separatorIndex < 3) {
+                // 'ab@gmail.com' -> '**@gmail.com'
+                return (email.slice(0, separatorIndex).replace(/./g, '*') +
+                    email.slice(separatorIndex));
+            }
+            // 'test42@gmail.com' -> 'te****@gmail.com'
+            return (email.slice(0, 2) +
+                email.slice(2, separatorIndex).replace(/./g, '*') +
+                email.slice(separatorIndex));
+        };
+        /**
+         * @remarks Generates a slug from a given string
+         * @param title - string to be converted to slug
+         * @returns slug
+         * @example
+         * ```typescript
+         * formatter.slugify('Hello World') // => hello-world
+         * ```
+         * */
+        this.slugify = (title) => {
+            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()
+                .toLowerCase();
+        };
+    }
+}
+const formatter = new Formatter();
+exports.default = formatter;

package/dist/lib/index.d.ts

@@ -1 +1,2 @@
 export { default as Crypto } from './cypto';
+export { default as Formatter } from './formatter';

package/dist/lib/index.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Crypto = void 0;
+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; } });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mhmdhammoud/meritt-utils",
-	"version": "1.0.2",
+	"version": "1.0.3",
 	"description": "",
 	"main": "./dist/index.js",
 	"private": false,
@@ -19,7 +19,7 @@
 		"types": "tsc --noemit",
 		"prepare": "husky install",
 		"lint": "eslint src --fix",
-		"prepublish": "yarn build"
+		"prepublish": "npm run build"
 	},
 	"dependencies": {
 		"dotenv": "^10.0.0"

package/src/index.ts

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

package/src/lib/cypto.ts

@@ -1,11 +1,9 @@
-/**
- * The Crypto class
- * @class Crypto
- * @example
- * ```typescript
- * import crypto from './lib/crypto'
- * ```
- * */
+/*
+	 Author : Omar Sawwas
+	 Date : 2023-06-17
+	 Description : RSA algorithm
+	 Version : 1.0
+*/
 class Crypto {
 	// Default variables
 	private _primeNumberP = 17
@@ -14,14 +12,17 @@ class Crypto {
 
 	/**
 	 * Set the P prime number for the RSA algorithm
-	 * @param {string} primeP - The prime number P
-	 * @memberof Crypto
+	 * @param primeP - The prime number P of type string
+	 * @returns void
 	 * @example
 	 * ```typescript
 	 * crypto.setPrimeP(17)
 	 * ```
 	 * */
 	public setPrimeP(primeP: number) {
+		if (isNaN(primeP)) {
+			throw new Error('Provide a valid number')
+		}
 		let isPrime = true
 		for (let i = 2; i < primeP; i++) {
 			if (primeP % i === 0) {
@@ -37,14 +38,17 @@ class Crypto {
 
 	/**
 	 * Set the Q prime number for the RSA algorithm
-	 * @param {string} primeQ - The prime number Q
-	 * @memberof Crypto
+	 * @param primeQ - The prime number Q of type string
+	 * @returns void
 	 * @example
 	 * ```typescript
 	 * crypto.setPrimeQ(19)
 	 * ```
 	 * */
 	public setPrimeQ(primeQ: number) {
+		if (isNaN(primeQ)) {
+			throw new Error('Provide a valid number')
+		}
 		let isPrime = true
 		for (let i = 2; i < primeQ; i++) {
 			if (primeQ % i === 0) {
@@ -60,15 +64,18 @@ class Crypto {
 
 	/**
 	 *
-	 * @param {string} base - The base number
-	 * @param {string} exponent - The exponent number
-	 * @memberof Crypto
+	 * @param base - The base number of type number
+	 * @param exponent - The exponent number of type number
+	 * @returns The modular exponentiation of the base and the exponent
 	 * @example
 	 * ```typescript
 	 * this.modularExponentiation(2, 3)
 	 * ```
 	 * */
 	private _modularExponentiation = (base: number, exponent: number) => {
+		if (isNaN(base) || isNaN(exponent)) {
+			throw new Error('Provide a valid number')
+		}
 		if (this._moduloDenominator === 1) {
 			return 0
 		}
@@ -86,34 +93,56 @@ class Crypto {
 
 	/**
 	 * Encrypt the message using the public key
-	 * @param {string} message - The message to encrypt
-	 * @param {string} publicKey - The public key
-	 * @memberof Crypto
+	 * @param message - The message to encrypt of type string|number|Record
+	 * @param publicKey - The public key to encrypt the message with of type number
+	 * @returns The encrypted message of type number[]
 	 * @example
 	 * ```typescript
 	 * crypto.encrypt('Hello World', 7)
 	 * ```
 	 * */
-	public encrypt = (message: string, publicKey: number): number[] => {
-		const b: number[] = []
+	public encrypt = (
+		message: string | number | Record<any, any>,
+		publicKey: number
+	): number[] => {
+		if (isNaN(publicKey)) {
+			throw new Error('Public key should be a number')
+		}
+		if (typeof message === 'number') {
+			message = message.toString()
+		}
+		if (typeof message === 'object') {
+			message = JSON.stringify(message)
+		}
+		const encryptedMessage: number[] = []
 		for (let i = 0; i < message.length; i++) {
 			const a = message.charCodeAt(i)
-			b.push(this._modularExponentiation(a, publicKey))
+			encryptedMessage.push(this._modularExponentiation(a, publicKey))
 		}
-		return b
+		return encryptedMessage
 	}
 
 	/**
 	 * Decrypt the message using the private key
-	 * @param {string} encryptedMessage - The ciphertext to decrypt
-	 * @param {string} privateKey - The private key
-	 * @memberof Crypto
+	 * @param encryptedMessage - The encryptedMessage to decrypt of type number[]
+	 * @param privateKey - The private key to decrypt the message with of type number
+	 * @returns The decrypted message of type string
 	 * @example
 	 * ```typescript
 	 * crypto.decrypt([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], 23)
 	 * ```
 	 * */
 	public decrypt = (encryptedMessage: number[], privateKey: number): string => {
+		if (isNaN(privateKey)) {
+			throw new Error('Private key should be a number')
+		}
+		if (!Array.isArray(encryptedMessage)) {
+			throw new Error('Encrypted message should be an array')
+		}
+		const allValidNumbers = encryptedMessage.every((number) => !isNaN(number))
+		if (!allValidNumbers) {
+			throw new Error('Encrypted message should be an array of numbers')
+		}
 		const decryptedAsciiMessage: number[] = []
 		for (let i = 0; i < encryptedMessage.length; i++) {
 			const a = encryptedMessage[i]

package/src/lib/formatter.ts

@@ -0,0 +1,121 @@
+/*
+	 Author : Mhmd Hammoud
+	 Date : 2023-06-17
+	 Description : String manipulation
+	 Version : 1.0
+*/
+class Formatter {
+	/**
+	 * @remarks Normalizes input by removing underscores and hyphens and capitalizing the first letter of the sentence.
+	 * @param stringToBeChanged - to be formatted without underscores and hyphens
+	 * @param withWhiteSpacing - Determines if white spacing is needed in the final string or not (default: true)
+	 * @returns string
+	 * @example
+	 * ```typescript
+	 * formatter.toUpperFirst('hello world')
+	 * // => 'Hello-World'
+	 * ```
+	 * */
+	toUpperFirst = (_: string | number, withSpacing = true) => {
+		if (typeof _ !== 'string') throw new Error('Provide a valid string')
+		if (withSpacing) {
+			return _.split(' ')
+				.map((val: string) => val.charAt(0).toUpperCase() + val.slice(1))
+				.join(' ')
+				.replace(/ /g, '-')
+				.replace(/\//g, '-')
+				.replace(/\./g, '')
+		} else {
+			return _.split(' ')
+				.map((val: string) => val.charAt(0).toUpperCase() + val.slice(1))
+				.join(' ')
+				.replace(/\//g, '-')
+				.replace(/\./g, '')
+		}
+	}
+
+	/**
+	 * @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) => {
+		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()
+			.replace(STRING_DASHERIZE_REGEXP, '-')
+	}
+
+	/**
+	 * @remarks obfuscates email address
+	 * @param email - email address to be obfuscated
+	 * @returns obfuscated email address
+	 * @example
+	 * ```typescript
+	 * formatter.obfuscate('johndoe@email.com') // => jo*****@gmail.com
+	 * ```
+	 * */
+	obfuscate = (email: string) => {
+		if (typeof email !== 'string') throw new Error('Provide a valid string')
+		const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+		if (!emailRegex.test(email))
+			throw new Error('Provide a valid email address')
+		const separatorIndex = email.indexOf('@')
+		if (separatorIndex < 3) {
+			// 'ab@gmail.com' -> '**@gmail.com'
+			return (
+				email.slice(0, separatorIndex).replace(/./g, '*') +
+				email.slice(separatorIndex)
+			)
+		}
+		// 'test42@gmail.com' -> 'te****@gmail.com'
+		return (
+			email.slice(0, 2) +
+			email.slice(2, separatorIndex).replace(/./g, '*') +
+			email.slice(separatorIndex)
+		)
+	}
+
+	/**
+	 * @remarks Generates a slug from a given string
+	 * @param title - string to be converted to slug
+	 * @returns slug
+	 * @example
+	 * ```typescript
+	 * formatter.slugify('Hello World') // => hello-world
+	 * ```
+	 * */
+	slugify = (title: 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()
+			.toLowerCase()
+	}
+}
+
+const formatter = new Formatter()
+export default formatter

package/src/lib/index.ts

@@ -1 +1,2 @@
 export {default as Crypto} from './cypto'
+export {default as Formatter} from './formatter'