@mongez/reinforcements 2.2.0 → 2.2.2

package/README.md

@@ -14,7 +14,23 @@ or using `npm`
 
 ## Usage
 
-## Getting value from an object
+We'll cover all reinforcements utilities by type, each type and mixed types and other utilities will be covered in a separate section.
+
+## Objects
+
+Here is the available utilities for objects:
+
+- [get](#getting-value-from-an-object): Get value from an object using dot notation syntax.
+- [set](#setting-value-in-object): Set value to an object using dot notation syntax.
+- [merge](#merging-objects-deeply): Merge objects deeply (Not shallow).
+- [clone](#clone-objects): Clone an object/array using deep clone (Not shallow).
+- [only](#getting-only-certain-keys-from-object): Get only the given keys from an object and return it as a new object.
+- [except](#getting-all-object-except-for-certain-keys): Get all object except for certain keys and return it as a new object.
+- [unset](#unset-keys-from-object): Unset keys from an object.
+- [flatten](#flatten-objects): Flatten a nested object into a single level object.
+- [sort](#sort-object-by-its-keys): Sort object by its keys.
+
+### Getting value from an object
 
 To get a value from an object using `dot.notation` syntax, you can use `get` function.
 
@@ -285,7 +301,7 @@ console.log(cloned.name.first); // Ali
 console.log(user.name.first); // Hasan
 ```
 
-### Getting certain values from object
+### Getting only certain keys from object
 
 To get a new object from the base object with only list of keys, use `only(object: object, keys: string[]): object`
 
@@ -593,188 +609,760 @@ Output:
 }
 ```
 
-## Equal Values
+## Arrays
 
-Using `areEqual` function will check if the given two values equal to each other, it will validate against any type such as objects, arrays, strings, numbers, booleans, null, undefined, symbols.
+Now let's move to arrays utilities.
+
+- [Group By](#group-by): Group array of objects by a certain key/keys.
+- [Pluck](#pluck): Get an array of values from an array of objects.
+- [Chunk](#chunk): Split array into chunks.
+- [Count](#count): Count the number of item that contains the given key or callback.
+- [Count By](#count-by): Count total occurrence of values for the given key.
+- [Even](#even): Get even numbers from an array or by given key.
+- [Odd](#odd): Get odd numbers from an array or by given key.
+- [Even Indexes](#even-indexes): Get elements in even indexes of an array.
+- [Odd Indexes](#odd-indexes): Get elements in odd indexes of an array.
+- [Min](#min): Get the minimum value from an array or by given key.
+- [Max](#max): Get the maximum value from an array or by given key.
+- [Sum](#sum): Get the sum of all values in an array or by given key.
+- [Average](#average): Get the average of all values in an array or by given key.
+- [Median](#median): Get the median of all values in an array or by given key.
+- [Unique](#unique): Get unique values from an array.
+- [Push Unique](#push-unique): Push a value or more to an array if it doesn't exist.
+- [Unshift Unique](#unshift-unique): Add a value or more to the beginning of an array if it doesn't exist.
+
+### Pluck
+
+Pluck a certain key/keys from an array of objects.
+
+`pluck(array: any[], key?: string | string[]): any[]`
 
 ```ts
-import { areEqual } from "@mongez/reinforcements";
+import { pluck } from "@mongez/reinforcements";
 
-console.log(areEqual(1, 1)); // true
+const array = [
+  { name: "John", age: 20 },
+  { name: "Jane", age: 25 },
+  { name: "Jack", age: 30 },
+];
 
-console.log(areEqual("1", 1)); // false
+console.log(pluck(array, "name")); // ["John", "Jane", "Jack"]
+```
 
-console.log(areEqual("1", "1")); // true
+You may also pluck multiple keys by passing an array of keys.
 
-console.log(areEqual(true, true)); // true
+```ts
+import { pluck } from "@mongez/reinforcements";
 
-console.log(areEqual(true, false)); // false
+const array = [
+  { name: "John", age: 20, job: "developer" },
+  { name: "Jane", age: 25, job: "designer" },
+  { name: "Jack", age: 30, job: "manager" },
+];
 
-console.log(areEqual(null, null)); // true
+console.log(pluck(array, ["name", "job"])); // [{name: "John", job: "developer"}, {name: "Jane", job: "designer"}, {name: "Jack", job: "manager"}]
+```
 
-console.log(areEqual(undefined, undefined)); // true
+### Group By
 
-console.log(areEqual(Symbol("1"), Symbol("1"))); // false
+Group an array of objects by a certain key or more.
 
-console.log(areEqual(Symbol("1"), Symbol("2"))); // false
+`groupBy(array: Record<string, any>[], groupByKey: string | string[], listAs = "data"): Record<string, any>[]`
 
-console.log(areEqual([1, 2, 3], [1, 2, 3])); // true
+Group by a single key:
 
-console.log(areEqual([1, 2, 3], [1, 2, 3, 4])); // false
+```ts
+import { groupBy } from "@mongez/reinforcements";
 
-console.log(areEqual({ id: 1 }, { id: 1 })); // true
+ const studentsClasses = [
+  {
+    id: 1,
+    class: "A",
+    grade: 1,
+  },
+  {
+    id: 2,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 3,
+    class: "A",
+    grade: 3,
+  },
+  {
+    id: 4,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 5,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 6,
+    class: "C",
+    grade: 5,
+  },
+];
 
-console.log(areEqual({ id: 1 }, { id: 2 })); // false
+console.log(groupBy(studentsClasses, "class"));
 ```
 
-## Generating Random Values
+Output:
 
-Another good feature is `Random` object, which allows us to generate variant random values of different types.
+```json
+[
+  {
+    "class": "A",
+    "data": [
+      {
+        "id": 1,
+        "class": "A",
+        "grade": 1
+      },
+      {
+        "id": 3,
+        "class": "A",
+        "grade": 3
+      }
+    ]
+  },
+  {
+    "class": "B",
+    "data": [
+      {
+        "id": 2,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 4,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 5,
+        "class": "B",
+        "grade": 2
+      }
+    ]
+  },
+  {
+    "class": "C",
+    "data": [
+      {
+        "id": 6,
+        "class": "C",
+        "grade": 5
+      }
+    ]
+  }
+]
+```
 
-### Generate random string
+Group By Multiple Keys:
 
-To generate a random string use `Random.string(length: number = 32): string` method.
+```ts
+import { groupBy } from "@mongez/reinforcements";
+
+const studentsClasses = [
+  {
+    id: 1,
+    class: "A",
+    grade: 1,
+  },
+  {
+    id: 2,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 3,
+    class: "A",
+    grade: 3,
+  },
+  {
+    id: 4,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 5,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 6,
+    class: "C",
+    grade: 5,
+  },
+];
+
+console.log(groupBy(studentsClasses, ["class", "grade"]));
+```
+
+Output:
+
+```json
+[
+  {
+    "class": "A",
+    "grade": 1,
+    "data": [
+      {
+        "id": 1,
+        "class": "A",
+        "grade": 1
+      }
+    ]
+  },
+  {
+    "class": "A",
+    "grade": 3,
+    "data": [
+      {
+        "id": 3,
+        "class": "A",
+        "grade": 3
+      }
+    ]
+  },
+  {
+    "class": "B",
+    "grade": 2,
+    "data": [
+      {
+        "id": 2,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 4,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 5,
+        "class": "B",
+        "grade": 2
+      }
+    ]
+  },
+  {
+    "class": "C",
+    "grade": 5,
+    "data": [
+      {
+        "id": 6,
+        "class": "C",
+        "grade": 5
+      }
+    ]
+  }
+]
+```
+
+You can also change the `data` key to any other key by passing the third argument.
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { groupBy } from "@mongez/reinforcements";
 
-Random.string(); // 4G8JyA4uM5YVMbkqVaoYnW6GzPcC64Fy
+const studentsClasses = [
+  {
+    id: 1,
+    class: "A",
+    grade: 1,
+  },
+  {
+    id: 2,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 3,
+    class: "A",
+    grade: 3,
+  },
+  {
+    id: 4,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 5,
+    class: "B",
+    grade: 2,
+  },
+  {
+    id: 6,
+    class: "C",
+    grade: 5,
+  },
+];
+
+console.log(groupBy(studentsClasses, ["class", "grade"], 'students'));
 ```
 
-To generate a random string with certain length, just pass the length value to the function.
+Output:
+
+```json
+[
+  {
+    "class": "A",
+    "grade": 1,
+    "students": [
+      {
+        "id": 1,
+        "class": "A",
+        "grade": 1
+      }
+    ]
+  },
+  {
+    "class": "A",
+    "grade": 3,
+    "students": [
+      {
+        "id": 3,
+        "class": "A",
+        "grade": 3
+      }
+    ]
+  },
+  {
+    "class": "B",
+    "grade": 2,
+    "students": [
+      {
+        "id": 2,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 4,
+        "class": "B",
+        "grade": 2
+      },
+      {
+        "id": 5,
+        "class": "B",
+        "grade": 2
+      }
+    ]
+  },
+  {
+    "class": "C",
+    "grade": 5,
+    "students": [
+      {
+        "id": 6,
+        "class": "C",
+        "grade": 5
+      }
+    ]
+  }
+]
+```
+
+### Chunk
+
+Split array into chunks.
+
+`chunk(array: any[] | string, size: number): any[]`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { chunk } from "@mongez/reinforcements";
 
-Random.string(12); // P057C06VPwxl
+const array = [1, 2, 3, 4, 5];
+
+console.log(chunk(array, 2)); // [[1, 2], [3, 4], [5]]
 ```
 
-### Generate random integer
+### Count
 
-To generate a random integer use `Random.int(min: number = 1, max: number = 9999999): number` method.
+Count the number of item that contains the given key or callback.
+
+`count(data: any[], key: string | Parameters<typeof Array.prototype.filter>[0]): number`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { count } from "@mongez/reinforcements";
 
-Random.int(); // 7387115
-Random.int(); // 9411554
-Random.int(); // 691593
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(count(array, "value")); // 5
 ```
 
-To set min value, pass first argument with minimum value
+We can also make a count using a callback.
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { count } from "@mongez/reinforcements";
 
-Random.int(10); // 7387115
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(count(array, (item) => item.value > 2)); // 3
 ```
 
-To set min and max value, pass second argument as well with maximum value
+### Count By
+
+Count total occurrence of values for the given key.
+
+`countBy(array: any[], key: string): { [key: string]: number`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { countBy } from "@mongez/reinforcements";
 
-Random.int(10, 100); // 36
+const array = [
+  { id: 1, animal: 'dog' },
+  { id: 2, animal: 'cat' },
+  { id: 3, animal: 'dog' },
+  { id: 4, animal: 'cat' },
+  { id: 5, animal: 'dog' },
+];
+
+console.log(countBy(array, 'animal')); // { dog: 3, cat: 2 }
 ```
 
-> `Random.integer` is an alias to `Random.int`.
+### Even
 
-### Generate random html id
+Get even numbers from the array or by the given key.
 
-This function will generate a valid random html id string `Random.id(length: number = 6, startsWith: string = "el-"): string`.
+`even(array: any[], key?: string): any[]`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { even } from "@mongez/reinforcements";
 
-Random.id(); // el-SDFefdvgtr2e3qw
-Random.id(); // el-fasrg3q
+const array = [1, 2, 3, 4, 5];
+
+console.log(even(array)); // [2, 4]
 ```
 
-You may set the length as first argument and/or set the id prefix as second argument (**default is el-**).
+We can also get even numbers by the given key.
 
-### Generate random boolean value
+```ts
+import { even } from "@mongez/reinforcements";
 
-To generate random boolean value use `Random.bool(): boolean` or `Random.boolean(): boolean`
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(even(array, "value")); // [2, 4]
+```
+
+### Odd
+
+Get odd numbers from the array or by the given key.
+
+`odd(array: any[], key?: string): any[]`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { odd } from "@mongez/reinforcements";
 
-Random.bool(); // true
-Random.bool(); // true
-Random.bool(); // false
-Random.boolean(); // false
-Random.boolean(); // true
-Random.boolean(); // false
+const array = [1, 2, 3, 4, 5];
+
+console.log(odd(array)); // [1, 3, 5]
 ```
 
-### Generate random color
+We can also get odd numbers by the given key.
 
-To generate random color use `Random.color(): string` method.
+```ts
+import { odd } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(odd(array, "value")); // [1, 3, 5]
+```
+
+### Even Indexes
+
+Get only array values in even indexes.
+
+`evenIndexes(array: any[]): any[]`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { evenIndexes } from "@mongez/reinforcements";
 
-Random.color(); // #f2f2f2
+const array = [1, 2, 3, 4, 5];
+
+console.log(evenIndexes(array)); // [1, 3, 5]
 ```
 
-### Generate random date
+### Odd Indexes
 
-To generate random date use `Random.date(min: Date = new Date(1970, 1, 1), max: Date = new Date()): Date` method.
+Get only array values in odd indexes.
+
+`oddIndexes(array: any[]): any[]`
 
 ```ts
-import { Random } from "@mongez/reinforcements";
+import { oddIndexes } from "@mongez/reinforcements";
 
-Random.date(); // 2020-12-12T12:12:12.000Z
+const array = [1, 2, 3, 4, 5];
 
-// Get random date between two dates
-Random.date(new Date(2010, 1, 1), new Date(2020, 1, 1)); // 2015-12-12T12:12:12.000Z
+console.log(oddIndexes(array)); // [2, 4]
+```
 
-// Get random date that is higher than the given date
-Random.date(new Date(2010, 1, 1)); // 2015-12-12T12:12:12.000Z
+### min
 
-// Get random date that is lower than the given date
-Random.date(null, new Date(2010, 1, 1)); // 2005-12-12T12:12:12.000Z
+Get the minimum value from the array or by the given key.
+
+`min(array: any[], key?: string): number`
+
+```ts
+import { min } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(min(array)); // 1
 ```
 
-## Round float numbers
+We can also get the minimum value by the given key.
 
-To round float numbers, use `round(value: number, precision: number = 2): number`.
+```ts
+import { min } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(min(array, "value")); // 1
+```
+
+### max
+
+Get the maximum value from the array or by the given key.
+
+`max(array: any[], key?: string): number`
 
 ```ts
-import { round } from "@mongez/reinforcements";
+import { max } from "@mongez/reinforcements";
 
-console.log(round(10.0001)); // 10
-console.log(round(10.0478878)); // 10.04
-console.log(round(10.6987894849)); // 10.69
-console.log(round(10.6987894849, 3)); // 10.698
+const array = [1, 2, 3, 4, 5];
+
+console.log(max(array)); // 5
+```
+
+We can also get the maximum value by the given key.
+
+```ts
+import { max } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(max(array, "value")); // 5
+```
+
+### sum
+
+Get the sum of all values in the array or by the given key.
+
+`sum(array: any[], key?: string): number`
+
+```ts
+import { sum } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(sum(array)); // 15
+```
+
+We can also get the sum of all values by the given key.
+
+```ts
+import { sum } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(sum(array, "value")); // 15
+```
+
+### Average
+
+Calculate the average of an array.
+
+`average(array: any[], key?: string): number`
+
+```ts
+import { average } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(average(array)); // 3
+```
+
+You can also get an average of an array of objects by passing the key of the property you want to get the average of.
+
+```ts
+import { average } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(average(array, "value")); // 3
+```
+
+### Median
+
+Calculate the median of an array or by the given key.
+
+`median(array: any[], key?: string): number`
+
+```ts
+import { median } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(median(array)); // 3
+```
+
+We can also get the median by the given key.
+
+```ts
+import { median } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+];
+
+console.log(median(array, "value")); // 3
+```
+
+### Unique
+
+Get unique values from the array or by the given key.
+
+`unique(array: any[], key?: string): any[]`
+
+```ts
+import { unique } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5];
+
+console.log(unique(array)); // [1, 2, 3, 4, 5]
+```
+
+We can also get unique values by the given key.
+
+```ts
+import { unique } from "@mongez/reinforcements";
+
+const array = [
+  { id: 1, value: 1 },
+  { id: 2, value: 2 },
+  { id: 3, value: 3 },
+  { id: 4, value: 4 },
+  { id: 5, value: 5 },
+  { id: 6, value: 1 },
+  { id: 7, value: 2 },
+  { id: 8, value: 3 },
+  { id: 9, value: 4 },
+  { id: 10, value: 5 },
+];
+
+console.log(unique(array, "value")); // [1, 2, 3, 4, 5]
+```
+
+### Push Unique
+
+Push a value or more to the array if it doesn't exist.
+
+`pushUnique<T = any>(array: T[], ...items: T[]): T[]`
+
+```ts
+import { pushUnique } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(pushUnique(array, 6, 5, 6, 1, 2, 4, 3)); // [1, 2, 3, 4, 5, 6]
+```
+
+### Unshift Unique
+
+Add a value or more to the beginning array if it doesn't exist.
+
+`unshiftUnique<T = any>(array: T[], ...items: T[]): T[]`
+
+```ts
+import { unshiftUnique } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(unshiftUnique(array, 6, 7, 5, 6, 1, 2, 4, 3)); // [7, 6, 1, 2, 3, 4, 5]
 ```
 
 ## Working With Strings
 
 The following list defines all available string utilities
 
-- `capitalize`
-- `toCamelCase`
-- `toSnakeCase`
-- `toKebabCase`
-- `toStudlyCase`
-- `ucfirst`
-- `toInputName`
-- `extension`
-- `readMoreChars`
-- `readMoreWords`
-- `replaceFirst`
-- `replaceLast`
-- `replaceAll`
-- `removeFirst`
-- `removeLast`
-- `repeatsOf`
-- `ltrim`
-- `trim`
-- `rtrim`
-- `startsWithArabic`
-
-### Capitalize words
+- [Capitalize](#capitalize): Capitalize the first letter of the given string.
+- [Camel Case](#camel-case): Convert the given string to camel case.
+- [Snake Case](#snake-case): Convert the given string to snake case.
+- [Kebab Case](#kebab-case): Convert the given string to kebab case.
+- [Studly/Pascal Case](#studly-case): Convert the given string to pascal/studly case.
+- [ucfirst](#ucfirst): Capitalize the first letter of each word in the given string.
+- [To Input Name](#toinputname): Convert a dot notation string to proper input name (Brackets).
+- [Extension](#extension): Get the extension of the given string.
+- [Read More Characters](#read-more-characters): Cut off the given string after the given number of characters.
+- [Read More Words](#read-more-words): Cut off the given string after the given number of words.
+- [Remove First](#remove-first-matched-string): Remove the first matched string from the given string.
+- [Remove Last](#remove-last-matched-string): Remove the last matched string from the given string.
+- [Replace First](#replace-first-matched-string): Replace the first matched string from the given string.
+- [Replace Last](#replace-last-matched-string): Replace the last matched string from the given string.
+- [Replace All](#replace-all-matched-string): Replace all matched strings from the given string.
+- [Repeats Of](#count-repeats-of-needle-in-a-string): Count Repeats of needle in a string.
+- [Trim](#trimming-values-from-string): Remove a string from the beginning and end of the given string.
+- [Trim Left](#trimming-values-from-string): Remove a string from the beginning of the given string.
+- [Trim Right](#trimming-values-from-string): Remove a string from the end of the given string.
+- [Starts With Arabic Letter](#detect-if-string-starts-with-arabic): Detect if string starts with Arabic letter.
+
+### Capitalize
 
 Capitalize each word in string Separated by whitespace `capitalize(string: string): string`.
 
@@ -786,7 +1374,7 @@ const words = "hello world";
 console.log(capitalize(words)); // Hello World
 ```
 
-### Convert string to camel case
+### Camel Case
 
 Convert string to camel case, each word in string Separated by **whitespace** **underscores** or **dashes** `toCamelCase(string: string, separator: string = "\\s+|-|/|_|\\."): string`.
 
@@ -800,7 +1388,7 @@ console.log(toCamelCase(words)); // helloWorld
 
 Any of following will be used as a separator for the text, `.` | `-` | `whitespace` | `/`, you can set the separator as second argument though.
 
-### Convert string to snake case
+### Snake Case
 
 Convert string to snake case, each word in string Separated by **whitespace** or **dashes** `toSnakeCase(string: string, separator: string = '_', lowerAll: boolean = true): string`.
 
@@ -834,7 +1422,7 @@ const words = "Hello World";
 console.log(toSnakeCase(words, '-', false)); // Hello_World
 ```
 
-### Convert string to kebab case
+### Kebab Case
 
 Convert string to kebab case, each word in string Separated by **whitespace** or **dashes** or **Upper Letters** `toKebabCase(string: string, lowerAll: boolean = true): string`.
 
@@ -858,7 +1446,7 @@ const words = "Hello World";
 console.log(toKebabCase(words, false)); // Hello-World
 ```
 
-### Convert string to studly case
+### Studly Case
 
 Convert string to studly case, each word in string Separated by **whitespace**, **underscores** or **dashes** `toStudlyCase(string: string, separator: string = "-|\\.|_|\\s"): string`.
 
@@ -872,7 +1460,7 @@ const words = "hello world";
 console.log(toStudlyCase(words)); // HelloWorld
 ```
 
-### Capitalize first word of string
+### Ucfirst
 
 Capitalize only first word of string `ucfirst(string: string): string`.
 
@@ -884,7 +1472,7 @@ const words = "hello world";
 console.log(ucfirst(words)); // Hello world
 ```
 
-### To input name
+### toInputName
 
 Convert dot notation syntax to valid html input name `toInputName(string: string): string`.
 
@@ -897,7 +1485,7 @@ console.log(toInputName(name)); // user[name]
 console.log(toInputName("keywords.en.list[]")); // keywords[en][list][]
 ```
 
-### Get extension of string
+### Extension
 
 Get the last extension in the string, the string that is suffix to last dot `.`.
 
@@ -973,6 +1561,20 @@ const words = "welcome home buddy, your are not safe at your home!";
 console.log(removeFirst(words, "home")); // welcome  buddy, your are not safe at your home!
 ```
 
+### Remove last matched string
+
+Remove the last matched needle to the given string.
+
+`removeLast(string: string, needle: string): string`
+
+```ts
+import { removeLast } from "@mongez/reinforcements";
+
+const words = "welcome home buddy, your are not safe at your home!";
+
+console.log(removeLast(words, "home")); // welcome home buddy, your are not safe at your !
+```
+
 ### Replace first matched string
 
 Replace the first matched needle to the given string.
@@ -1015,20 +1617,6 @@ const words = "welcome home buddy, your are not safe at your home!";
 console.log(replaceAll(words, "home", "country")); // welcome country buddy, your are not safe at your country!
 ```
 
-### Remove last matched string
-
-Remove the last matched needle to the given string.
-
-`removeLast(string: string, needle: string): string`
-
-```ts
-import { removeLast } from "@mongez/reinforcements";
-
-const words = "welcome home buddy, your are not safe at your home!";
-
-console.log(removeLast(words, "home")); // welcome home buddy, your are not safe at your !
-```
-
 ### Count repeats of needle in a string
 
 Count repeats of a needle in the given string.
@@ -1131,7 +1719,7 @@ const string = "home/";
 console.log(rtrim(string, "/")); // /home
 ```
 
-## Detect if string starts with Arabic
+### Detect if string starts with Arabic
 
 Determine if the string starts with Arabic letter.
 
@@ -1148,7 +1736,92 @@ console.log(startsWithArabic(string)); // false
 console.log(startsWithArabic(arabicString)); // true
 ```
 
-## Debounce
+## Numbers
+
+Here are the aviation numbers utilities.
+
+- [Round](#round-float-numbers): Round numbers to a certain decimal places.
+
+### Round float numbers
+
+To round float numbers, use `round(value: number, precision: number = 2): number`.
+
+```ts
+import { round } from "@mongez/reinforcements";
+
+console.log(round(10.0001)); // 10
+console.log(round(10.0478878)); // 10.04
+console.log(round(10.6987894849)); // 10.69
+console.log(round(10.6987894849, 3)); // 10.698
+```
+
+## Mixed Utilities
+
+This section covers utilities that work with multiple types.
+
+- [Are Equal](#equal-values): Check if the two values are equal regardless of their type.
+- [Shuffle](#shuffle): Shuffle an array or a string.
+
+### Equal Values
+
+Using `areEqual` function will check if the given two values equal to each other, it will validate against any type such as objects, arrays, strings, numbers, booleans, null, undefined, symbols.
+
+```ts
+import { areEqual } from "@mongez/reinforcements";
+
+console.log(areEqual(1, 1)); // true
+
+console.log(areEqual("1", 1)); // false
+
+console.log(areEqual("1", "1")); // true
+
+console.log(areEqual(true, true)); // true
+
+console.log(areEqual(true, false)); // false
+
+console.log(areEqual(null, null)); // true
+
+console.log(areEqual(undefined, undefined)); // true
+
+console.log(areEqual(Symbol("1"), Symbol("1"))); // false
+
+console.log(areEqual(Symbol("1"), Symbol("2"))); // false
+
+console.log(areEqual([1, 2, 3], [1, 2, 3])); // true
+
+console.log(areEqual([1, 2, 3], [1, 2, 3, 4])); // false
+
+console.log(areEqual({ id: 1 }, { id: 1 })); // true
+
+console.log(areEqual({ id: 1 }, { id: 2 })); // false
+```
+
+### Shuffle
+
+Shuffle an array or a string.
+
+`shuffle(value: any[] | string): any[] | string`
+
+```ts
+import { shuffle } from "@mongez/reinforcements";
+
+const array = [1, 2, 3, 4, 5];
+
+console.log(shuffle(array)); // [2, 4, 1, 5, 3]
+
+const string = "Hello World";
+
+console.log(shuffle(string)); // "WlloHrodl"
+```
+
+## General Utilities
+
+The section covers general utilities that can be used in any project.
+
+- [Debounce](#debounce): Debounce a function to be called after a specific time.
+- [Escape Regex](#escape-regex): Escape regex special characters.
+
+### Debounce
 
 `debounce(callback: Function, timer: number = 0): void`
 
@@ -1201,6 +1874,129 @@ function sendEmail(e: any) {
 <button click={sendEmail}>Send Email</button>;
 ```
 
+### Escape Regex
+
+`escapeRegex(string: string): string`
+
+Escape regex special characters in the given string.
+
+```ts
+import { escapeRegex } from "@mongez/reinforcements";
+
+const string = "This is a string with special characters like: . * + ? ^ $ { } ( ) | [ ] / \\";
+
+console.log(escapeRegex(string)); // This is a string with special characters like: \\. \\* \\+ \\? \\^ \\$ \\{ \\} \\( \\) \\| \\[ \\] / \\\\
+```
+
+## Random
+
+Another good feature is `Random` object, which allows us to generate variant random values of different types.
+
+### Generate random string
+
+To generate a random string use `Random.string(length: number = 32): string` method.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.string(); // 4G8JyA4uM5YVMbkqVaoYnW6GzPcC64Fy
+```
+
+To generate a random string with certain length, just pass the length value to the function.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.string(12); // P057C06VPwxl
+```
+
+### Generate random integer
+
+To generate a random integer use `Random.int(min: number = 1, max: number = 9999999): number` method.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.int(); // 7387115
+Random.int(); // 9411554
+Random.int(); // 691593
+```
+
+To set min value, pass first argument with minimum value
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.int(10); // 7387115
+```
+
+To set min and max value, pass second argument as well with maximum value
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.int(10, 100); // 36
+```
+
+> `Random.integer` is an alias to `Random.int`.
+
+### Generate random html id
+
+This function will generate a valid random html id string `Random.id(length: number = 6, startsWith: string = "el-"): string`.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.id(); // el-SDFefdvgtr2e3qw
+Random.id(); // el-fasrg3q
+```
+
+You may set the length as first argument and/or set the id prefix as second argument (**default is el-**).
+
+### Generate random boolean value
+
+To generate random boolean value use `Random.bool(): boolean` or `Random.boolean(): boolean`
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.bool(); // true
+Random.bool(); // true
+Random.bool(); // false
+Random.boolean(); // false
+Random.boolean(); // true
+Random.boolean(); // false
+```
+
+### Generate random color
+
+To generate random color use `Random.color(): string` method.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.color(); // #f2f2f2
+```
+
+### Generate random date
+
+To generate random date use `Random.date(min: Date = new Date(1970, 1, 1), max: Date = new Date()): Date` method.
+
+```ts
+import { Random } from "@mongez/reinforcements";
+
+Random.date(); // 2020-12-12T12:12:12.000Z
+
+// Get random date between two dates
+Random.date(new Date(2010, 1, 1), new Date(2020, 1, 1)); // 2015-12-12T12:12:12.000Z
+
+// Get random date that is higher than the given date
+Random.date(new Date(2010, 1, 1)); // 2015-12-12T12:12:12.000Z
+
+// Get random date that is lower than the given date
+Random.date(null, new Date(2010, 1, 1)); // 2005-12-12T12:12:12.000Z
+```
+
 ## Tests
 
 To run tests run `npm run test` or `yarn test`