@mhmdhammoud/meritt-utils 1.0.2 → 1.0.4

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

@@ -0,0 +1,43 @@
+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}}
+  notify:
+    needs: [publish-npm]
+    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/.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

@@ -2,6 +2,10 @@
 
 This is a collection of utility functions that are often used in Meritt projects.
 
+## Actions
+
+[![Changes](https://github.com/Mhmdhammoud/meritt-utils/actions/workflows/push.yml/badge.svg)](https://github.com/Mhmdhammoud/meritt-utils/actions/workflows/push.yml) [![NPM Publish on Release](https://github.com/Mhmdhammoud/meritt-utils/actions/workflows/npm-publish.yml/badge.svg)](https://github.com/Mhmdhammoud/meritt-utils/actions/workflows/npm-publish.yml)
+
 ## Installation
 
 For npm:
@@ -19,9 +23,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 creating a product slug
+const slug = Formatter.slugify('My Product Name') // my-product-name
+
+// Example of encrypting and decrypting a string
 
-// Example of getting all Crypto methods
-const encryptedMessage = Crypto.encrypt('Hello World', 7)
-const decryptedMessage = Crypto.decrypt(encryptedMessage, 7)
+const encryptedMessage = Crypto.encrypt('Hello World', 7) // [23,235,141,414]
 ```

package/ReleaseNotes.md

@@ -0,0 +1,59 @@
+# Changes
+
+## Version 1.0.4
+
+### Added
+
+- Added generateKeys method that returns public and private keys
+
+```typescript
+import {Crypto} from '@mhmdhammoud/meritt-utils'
+
+// Example of generating a public and a private key
+const response = Crypto.generateKeys()
+console.log(response)
+
+{
+    publicKey:7,
+    privateKey:247,
+}
+
+
+```
+
+### Fixes and Improvements
+
+- Checking for prime numbers discarding even and odd numbers and skips 6 iterations at a time until radical I
+
+## 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,22 @@
-/**
- * The Crypto class
- * @class Crypto
- * @example
- * ```typescript
- * import crypto from './lib/crypto'
- * ```
- * */
 declare class Crypto {
     private _primeNumberP;
     private _primeNumberQ;
+    private _phiN;
     private _moduloDenominator;
+    /**
+     *
+     * @param number - The number to check if prime
+     * @returns The boolean answer of prime checking operation
+     * @example
+     * ```typescript
+     * this._isPrime(5)
+     * ```
+     * */
+    private _isPrime;
     /**
      * 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 +25,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,31 +35,61 @@ 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)
      * ```
      * */
     private _modularExponentiation;
+    /**
+     *
+     * @param temporaryVarriableOne - The number one
+     * @param temporaryVarriableTwo- The  number two (phi n)
+     * @returns The boolean answer of relatively prime checking operation with phi n
+     * @example
+     * ```typescript
+     * this._areRelativelyPrime(5,9)
+     * ```
+     * */
+    private _areRelativelyPrime;
+    /**
+     *
+     * @returns The public and private key number which is a random number generated to match conditions set by RSA algorithm
+     * @example
+     * ```typescript
+     * crypto.generateKeys()
+     * ```
+     * */
+    generateKeys: () => Record<'publicKey' | 'privateKey', number>;
+    /**
+     *
+     * @param publicKey - The public key number
+     * @returns The private key number which is the modulus inverse with repect to modulo denominator
+     * @example
+     * ```typescript
+     * crypto.generatePrivateKey(5)
+     * ```
+     * */
+    private _generatePrivateKey;
     /**
      * 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,30 +1,58 @@
 "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
         this._primeNumberP = 17;
         this._primeNumberQ = 19;
+        this._phiN = (this._primeNumberP - 1) * (this._primeNumberQ - 1);
         this._moduloDenominator = this._primeNumberP * this._primeNumberQ;
         /**
          *
-         * @param {string} base - The base number
-         * @param {string} exponent - The exponent number
-         * @memberof Crypto
+         * @param number - The number to check if prime
+         * @returns The boolean answer of prime checking operation
+         * @example
+         * ```typescript
+         * this._isPrime(5)
+         * ```
+         * */
+        this._isPrime = (number) => {
+            if (number <= 1) {
+                return false;
+            }
+            if (number <= 3) {
+                return true;
+            }
+            if (number % 2 === 0 || number % 3 === 0) {
+                return false;
+            }
+            for (let i = 5; i * i <= number; i += 6) {
+                if (number % i === 0 || number % (i + 2) === 0) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        /**
+         *
+         * @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;
             }
@@ -39,35 +67,144 @@ class Crypto {
             }
             return result;
         };
+        /**
+         *
+         * @param temporaryVarriableOne - The number one
+         * @param temporaryVarriableTwo- The  number two (phi n)
+         * @returns The boolean answer of relatively prime checking operation with phi n
+         * @example
+         * ```typescript
+         * this._areRelativelyPrime(5,9)
+         * ```
+         * */
+        this._areRelativelyPrime = (temporaryVarriableOne, temporaryVarriableTwo) => {
+            while (temporaryVarriableTwo !== 0) {
+                const temp = temporaryVarriableTwo;
+                temporaryVarriableTwo = temporaryVarriableOne % temporaryVarriableTwo;
+                temporaryVarriableOne = temp;
+            }
+            return temporaryVarriableOne === 1;
+        };
+        /**
+         *
+         * @returns The public and private key number which is a random number generated to match conditions set by RSA algorithm
+         * @example
+         * ```typescript
+         * crypto.generateKeys()
+         * ```
+         * */
+        this.generateKeys = () => {
+            const temporaryArray = [];
+            for (let i = 2; i < this._phiN; i++) {
+                if (this._areRelativelyPrime(i, this._phiN)) {
+                    temporaryArray.push(i);
+                }
+            }
+            if (temporaryArray.length === 0)
+                throw new Error('No public key options found!');
+            const randomIndex = Math.floor(Math.random() * temporaryArray.length);
+            // return temporaryArray[randomIndex]
+            const publicKey = temporaryArray[randomIndex];
+            const privateKey = this._generatePrivateKey(publicKey);
+            if (privateKey === publicKey) {
+                return this.generateKeys();
+            }
+            return {
+                privateKey: publicKey,
+                publicKey: privateKey,
+            };
+        };
+        /**
+         *
+         * @param publicKey - The public key number
+         * @returns The private key number which is the modulus inverse with repect to modulo denominator
+         * @example
+         * ```typescript
+         * crypto.generatePrivateKey(5)
+         * ```
+         * */
+        this._generatePrivateKey = (publicKey) => {
+            if (publicKey <= 1 || isNaN(publicKey)) {
+                throw new Error('Public key should be a number greater than 1');
+            }
+            if (!this._areRelativelyPrime(publicKey, this._phiN)) {
+                throw new Error('Public key should be relatively prime with respect to phi N');
+            }
+            let t1 = 0;
+            let t2 = 1;
+            let r1 = this._phiN;
+            let r2 = publicKey;
+            while (r2 !== 0) {
+                const quotient = Math.floor(r1 / r2);
+                const temp1 = t1;
+                const temp2 = r1;
+                t1 = t2;
+                r1 = r2;
+                t2 = temp1 - quotient * t2;
+                r2 = temp2 - quotient * r2;
+            }
+            if (r1 > 1) {
+                throw new Error('The number does not have a modular inverse.');
+            }
+            if (t1 < 0) {
+                t1 += this._phiN;
+            }
+            return t1;
+        };
         /**
          * 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 (publicKey <= 0) {
+                throw new Error('Private key should be a positive number different than 0');
+            }
+            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('Public key should be a number');
+            }
+            if (privateKey <= 0) {
+                throw new Error('Private key should be a positive number different than 0');
+            }
+            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,44 +219,36 @@ 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) {
-        let isPrime = true;
-        for (let i = 2; i < primeP; i++) {
-            if (primeP % i === 0) {
-                isPrime = false;
-                break;
-            }
+        if (isNaN(primeP) || primeP === 0) {
+            throw new Error('Provide a valid number');
         }
-        if (!isPrime) {
+        if (!this._isPrime(primeP)) {
             throw new Error('The number is not prime');
         }
         this._primeNumberP = primeP;
     }
     /**
      * 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) {
-        let isPrime = true;
-        for (let i = 2; i < primeQ; i++) {
-            if (primeQ % i === 0) {
-                isPrime = false;
-                break;
-            }
+        if (isNaN(primeQ) || primeQ === 0) {
+            throw new Error('Provide a valid number');
         }
-        if (!isPrime) {
+        if (!this._isPrime(primeQ)) {
             throw new Error('The number is not prime');
         }
         this._primeNumberQ = primeQ;

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.4",
 	"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,35 +1,64 @@
-/**
- * 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
 	private _primeNumberQ = 19
+	private _phiN = (this._primeNumberP - 1) * (this._primeNumberQ - 1)
 	private _moduloDenominator = this._primeNumberP * this._primeNumberQ
 
+	/**
+	 *
+	 * @param number - The number to check if prime
+	 * @returns The boolean answer of prime checking operation
+	 * @example
+	 * ```typescript
+	 * this._isPrime(5)
+	 * ```
+	 * */
+
+	private _isPrime = (number: number): boolean => {
+		if (number <= 1) {
+			return false
+		}
+
+		if (number <= 3) {
+			return true
+		}
+
+		if (number % 2 === 0 || number % 3 === 0) {
+			return false
+		}
+
+		for (let i = 5; i * i <= number; i += 6) {
+			if (number % i === 0 || number % (i + 2) === 0) {
+				return false
+			}
+		}
+
+		return true
+	}
+
 	/**
 	 * 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) {
-		let isPrime = true
-		for (let i = 2; i < primeP; i++) {
-			if (primeP % i === 0) {
-				isPrime = false
-				break
-			}
+		if (isNaN(primeP) || primeP === 0) {
+			throw new Error('Provide a valid number')
 		}
-		if (!isPrime) {
+
+		if (!this._isPrime(primeP)) {
 			throw new Error('The number is not prime')
 		}
 		this._primeNumberP = primeP
@@ -37,22 +66,19 @@ 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) {
-		let isPrime = true
-		for (let i = 2; i < primeQ; i++) {
-			if (primeQ % i === 0) {
-				isPrime = false
-				break
-			}
+		if (isNaN(primeQ) || primeQ === 0) {
+			throw new Error('Provide a valid number')
 		}
-		if (!isPrime) {
+		if (!this._isPrime(primeQ)) {
 			throw new Error('The number is not prime')
 		}
 		this._primeNumberQ = primeQ
@@ -60,15 +86,19 @@ 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
 		}
@@ -84,36 +114,172 @@ class Crypto {
 		return result
 	}
 
+	/**
+	 *
+	 * @param temporaryVarriableOne - The number one
+	 * @param temporaryVarriableTwo- The  number two (phi n)
+	 * @returns The boolean answer of relatively prime checking operation with phi n
+	 * @example
+	 * ```typescript
+	 * this._areRelativelyPrime(5,9)
+	 * ```
+	 * */
+
+	private _areRelativelyPrime = (
+		temporaryVarriableOne: number,
+		temporaryVarriableTwo: number
+	) => {
+		while (temporaryVarriableTwo !== 0) {
+			const temp = temporaryVarriableTwo
+			temporaryVarriableTwo = temporaryVarriableOne % temporaryVarriableTwo
+			temporaryVarriableOne = temp
+		}
+		return temporaryVarriableOne === 1
+	}
+
+	/**
+	 *
+	 * @returns The public and private key number which is a random number generated to match conditions set by RSA algorithm
+	 * @example
+	 * ```typescript
+	 * crypto.generateKeys()
+	 * ```
+	 * */
+
+	public generateKeys = (): Record<'publicKey' | 'privateKey', number> => {
+		const temporaryArray: number[] = []
+		for (let i = 2; i < this._phiN; i++) {
+			if (this._areRelativelyPrime(i, this._phiN)) {
+				temporaryArray.push(i)
+			}
+		}
+		if (temporaryArray.length === 0)
+			throw new Error('No public key options found!')
+		const randomIndex = Math.floor(Math.random() * temporaryArray.length)
+		// return temporaryArray[randomIndex]
+		const publicKey = temporaryArray[randomIndex]
+		const privateKey = this._generatePrivateKey(publicKey)
+		if (privateKey === publicKey) {
+			return this.generateKeys()
+		}
+		return {
+			privateKey: publicKey,
+			publicKey: privateKey,
+		}
+	}
+
+	/**
+	 *
+	 * @param publicKey - The public key number
+	 * @returns The private key number which is the modulus inverse with repect to modulo denominator
+	 * @example
+	 * ```typescript
+	 * crypto.generatePrivateKey(5)
+	 * ```
+	 * */
+
+	private _generatePrivateKey = (publicKey: number): number => {
+		if (publicKey <= 1 || isNaN(publicKey)) {
+			throw new Error('Public key should be a number greater than 1')
+		}
+
+		if (!this._areRelativelyPrime(publicKey, this._phiN)) {
+			throw new Error(
+				'Public key should be relatively prime with respect to phi N'
+			)
+		}
+
+		let t1 = 0
+		let t2 = 1
+		let r1 = this._phiN
+		let r2 = publicKey
+
+		while (r2 !== 0) {
+			const quotient = Math.floor(r1 / r2)
+			const temp1 = t1
+			const temp2 = r1
+
+			t1 = t2
+			r1 = r2
+
+			t2 = temp1 - quotient * t2
+			r2 = temp2 - quotient * r2
+		}
+
+		if (r1 > 1) {
+			throw new Error('The number does not have a modular inverse.')
+		}
+
+		if (t1 < 0) {
+			t1 += this._phiN
+		}
+
+		return t1
+	}
+
 	/**
 	 * 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 (publicKey <= 0) {
+			throw new Error(
+				'Private key should be a positive number different than 0'
+			)
+		}
+		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('Public key should be a number')
+		}
+		if (privateKey <= 0) {
+			throw new Error(
+				'Private key should be a positive number different than 0'
+			)
+		}
+		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'