@etsoo/shared 1.0.74 → 1.0.78

package/README.md

@@ -122,13 +122,17 @@ Storage related utilities
 |setLocalData|Set local storage data|
 |setSessionData|Set session storage data|
 |getLocalData|Get local storage data|
+|getLocalObject|Get local storage object data|
 |getSessionData|Get session storage data|
+|getSessionObject|Get session storage object data|
 
 ## Utils
 String and other related utilities
 
 |Name|Description|
 |---:|---|
+|charsToNumber|Base64 chars to number|
+|equals|Two values equal|
 |formatInitial|Format inital character to lower case or upper case|
 |formatString|Format string with parameters|
 |getDataChanges|Get data changed fields with input data updated|
@@ -137,7 +141,10 @@ String and other related utilities
 |mergeFormData|Merge form data to primary one|
 |mergeClasses|Merge class names|
 |newGUID|Create a GUID|
+|numberToChars|Number to base64 chars|
 |objectEqual|Test two objects are equal or not|
+|objectKeys|Get two object's unqiue properties|
+|objectUpdated|Get the new object's updated fields contrast to the previous object|
 |parseString|Parse string (JSON) to specific type|
 |setLabels|Set source with new labels|
 |snakeNameToWord|Snake name to works, 'snake_name' to 'Snake Name'|

package/__tests__/StorageUtils.ts

@@ -12,3 +12,17 @@ test('Tests for all', () => {
     expect(StorageUtils.getSessionData('number', 0)).toBe(3.14);
     expect(StorageUtils.getSessionData('test', {})).toHaveProperty('id', 123);
 });
+
+test('Tests for getLocalObject', () => {
+    StorageUtils.setLocalData('test', { id: 123, name: 'test' });
+    const data = StorageUtils.getLocalObject<{ id: number }>('test');
+    expect(data?.id).toBe(123);
+    expect(data).toHaveProperty('name', 'test');
+});
+
+test('Tests for getSessionObject', () => {
+    StorageUtils.setSessionData('test', { id: 123, name: 'test' });
+    const data = StorageUtils.getSessionObject<{ id: number }>('test');
+    expect(data?.id).toBe(123);
+    expect(data).toHaveProperty('name', 'test');
+});

package/__tests__/Utils.ts

@@ -9,7 +9,8 @@ test('Tests for getDataChanges', () => {
         price: '6.0',
         amount: '',
         enabled: true,
-        value: undefined
+        value: undefined,
+        ids: [1, 2]
     };
     const initData = {
         id: 1,
@@ -18,7 +19,8 @@ test('Tests for getDataChanges', () => {
         brand: 'ETSOO',
         price: 6,
         amount: 0,
-        enabled: true
+        enabled: true,
+        ids: [1, 2]
     };
     const fields = Utils.getDataChanges(input, initData);
     expect(fields).toStrictEqual(['gender', 'brand', 'amount']);
@@ -67,6 +69,13 @@ test('Tests for newGUID', () => {
     expect(id1.length).toBe(id2.length);
 });
 
+test('Tests for numberToChars and charsToNumber', () => {
+    const num = 1638777042242;
+    const chars = Utils.numberToChars(num);
+    expect(chars).toEqual('QmpkdVgv');
+    expect(Utils.charsToNumber(chars)).toEqual(num);
+});
+
 test('Tests for removeNonLetters', () => {
     const input = '1234-5678@abc.';
     const result = '12345678abc';
@@ -75,14 +84,21 @@ test('Tests for removeNonLetters', () => {
 });
 
 test('Tests for objectEqual', () => {
-    const obj1 = { a: 1, b: 'abc', c: true, d: null };
-    const obj2 = { a: '1', b: 'abc', c: true };
+    const obj1 = { a: 1, b: 'abc', c: true, d: null, f: [1, 2] };
+    const obj2 = { a: '1', b: 'abc', c: true, f: [1, 2] };
     expect(Utils.objectEqual(obj1, obj2)).toBeFalsy();
     expect(Utils.objectEqual(obj1, obj2, [], 0)).toBeTruthy();
     expect(Utils.objectEqual(obj1, obj2, ['a'])).toBeTruthy();
     expect(Utils.objectEqual(obj1, obj2, ['a'], 2)).toBeFalsy();
 });
 
+test('Tests for objectUpdated', () => {
+    const objPrev = { a: 1, b: 'abc', c: true, d: null, f: [1, 2] };
+    const objNew = { a: 2, b: 'abc', d: new Date(), f: [1, 2, 3] };
+    const fields = Utils.objectUpdated(objNew, objPrev, ['d']);
+    expect(fields.sort()).toStrictEqual(['a', 'c', 'f']);
+});
+
 test('Tests for parseString', () => {
     expect(Utils.parseString('test', '')).toBe('test');
     expect(Utils.parseString('true', false)).toBe(true);

package/lib/cjs/StorageUtils.d.ts

@@ -21,9 +21,19 @@ export declare namespace StorageUtils {
      * @param defaultValue Default value
      */
     function getLocalData<T>(key: string, defaultValue: T): T;
+    /**
+     * Get local storage object data
+     * @param key Key name
+     */
+    function getLocalObject<T extends {}>(key: string): T | undefined;
     /**
      * Get session storage data
      * @param key Key name
      */
     function getSessionData<T>(key: string, defaultValue: T): T;
+    /**
+     * Get session storage object data
+     * @param key Key name
+     */
+    function getSessionObject<T extends {}>(key: string): T | undefined;
 }

package/lib/cjs/StorageUtils.js

@@ -51,6 +51,18 @@ var StorageUtils;
         return Utils_1.Utils.parseString(data, defaultValue);
     }
     StorageUtils.getLocalData = getLocalData;
+    /**
+     * Get local storage object data
+     * @param key Key name
+     */
+    function getLocalObject(key) {
+        // Get storage
+        const data = localStorage.getItem(key);
+        if (data == null)
+            return undefined;
+        return JSON.parse(data);
+    }
+    StorageUtils.getLocalObject = getLocalObject;
     /**
      * Get session storage data
      * @param key Key name
@@ -62,4 +74,16 @@ var StorageUtils;
         return Utils_1.Utils.parseString(data, defaultValue);
     }
     StorageUtils.getSessionData = getSessionData;
+    /**
+     * Get session storage object data
+     * @param key Key name
+     */
+    function getSessionObject(key) {
+        // Get storage
+        const data = sessionStorage.getItem(key);
+        if (data == null)
+            return undefined;
+        return JSON.parse(data);
+    }
+    StorageUtils.getSessionObject = getSessionObject;
 })(StorageUtils = exports.StorageUtils || (exports.StorageUtils = {}));

package/lib/cjs/Utils.d.ts

@@ -35,6 +35,19 @@ declare global {
  * Utilities
  */
 export declare namespace Utils {
+    /**
+     * Base64 chars to number
+     * @param base64Chars Base64 chars
+     * @returns Number
+     */
+    function charsToNumber(base64Chars: string): number;
+    /**
+     * Two values equal
+     * @param v1 Value 1
+     * @param v2 Value 2
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     */
+    function equals(v1: unknown, v2: unknown, strict?: number): boolean;
     /**
      * Format inital character to lower case or upper case
      * @param input Input string
@@ -89,6 +102,12 @@ export declare namespace Utils {
      * Create a GUID
      */
     function newGUID(): string;
+    /**
+     * Number to base64 chars
+     * @param num Input number
+     * @returns Result
+     */
+    function numberToChars(num: number): string;
     /**
      * Test two objects are equal or not
      * @param obj1 Object 1
@@ -98,6 +117,23 @@ export declare namespace Utils {
      * @returns Result
      */
     function objectEqual(obj1: {}, obj2: {}, ignoreFields?: string[], strict?: number): boolean;
+    /**
+     * Get two object's unqiue properties
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @returns Unique properties
+     */
+    function objectKeys(obj1: {}, obj2: {}, ignoreFields?: string[]): Set<string>;
+    /**
+     * Get the new object's updated fields contrast to the previous object
+     * @param objNew New object
+     * @param objPre Previous object
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Updated fields
+     */
+    function objectUpdated(objNew: {}, objPrev: {}, ignoreFields?: string[], strict?: number): string[];
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/cjs/Utils.js

@@ -29,6 +29,43 @@ String.prototype.removeNonLetters = function () {
  */
 var Utils;
 (function (Utils) {
+    /**
+     * Base64 chars to number
+     * @param base64Chars Base64 chars
+     * @returns Number
+     */
+    function charsToNumber(base64Chars) {
+        const chars = typeof Buffer === 'undefined'
+            ? [...atob(base64Chars)].map((char) => char.charCodeAt(0))
+            : [...Buffer.from(base64Chars, 'base64')];
+        return chars.reduce((previousValue, currentValue, currentIndex) => {
+            return previousValue + currentValue * Math.pow(128, currentIndex);
+        }, 0);
+    }
+    Utils.charsToNumber = charsToNumber;
+    /**
+     * Two values equal
+     * @param v1 Value 1
+     * @param v2 Value 2
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     */
+    function equals(v1, v2, strict = 1) {
+        // Null and undefined case
+        if (v1 == null || v2 == null) {
+            if (strict <= 1 && v1 == v2)
+                return true;
+            return v1 === v2;
+        }
+        // For array and object
+        if (typeof v1 === 'object')
+            return JSON.stringify(v1) === JSON.stringify(v2);
+        // 1 and '1' case
+        if (strict === 0)
+            return v1 == v2;
+        // Strict equal
+        return v1 === v2;
+    }
+    Utils.equals = equals;
     /**
      * Format inital character to lower case or upper case
      * @param input Input string
@@ -71,7 +108,7 @@ var Utils;
             }
             if (initValue != null) {
                 const newValue = DataTypes_1.DataTypes.convert(value, initValue);
-                if (newValue === initValue) {
+                if (Utils.equals(newValue, initValue)) {
                     Reflect.deleteProperty(input, key);
                     return;
                 }
@@ -149,6 +186,27 @@ var Utils;
         });
     }
     Utils.newGUID = newGUID;
+    /**
+     * Number to base64 chars
+     * @param num Input number
+     * @returns Result
+     */
+    function numberToChars(num) {
+        const codes = [];
+        while (num > 0) {
+            const code = num % 128;
+            codes.push(code);
+            num = (num - code) / 128;
+        }
+        if (typeof Buffer === 'undefined') {
+            return btoa(String.fromCharCode(...codes));
+        }
+        else {
+            const buffer = Buffer.from(codes);
+            return buffer.toString('base64');
+        }
+    }
+    Utils.numberToChars = numberToChars;
     /**
      * Test two objects are equal or not
      * @param obj1 Object 1
@@ -158,28 +216,56 @@ var Utils;
      * @returns Result
      */
     function objectEqual(obj1, obj2, ignoreFields = [], strict = 1) {
-        // Keys
-        const keys = new Set([
-            ...Object.keys(obj1).filter((item) => !ignoreFields.includes(item)),
-            ...Object.keys(obj2).filter((item) => !ignoreFields.includes(item))
-        ]);
+        // Unique keys
+        const keys = Utils.objectKeys(obj1, obj2, ignoreFields);
         for (const key of keys) {
             // Values
             const v1 = Reflect.get(obj1, key);
             const v2 = Reflect.get(obj2, key);
-            // Null and undefined case
-            if (v1 == null && v2 == null && strict <= 1)
-                continue;
-            // 1 and '1' case
-            if (strict === 0 && v1 == v2)
-                continue;
-            // Strict equal
-            if (v1 !== v2)
+            if (!Utils.equals(v1, v2, strict))
                 return false;
         }
         return true;
     }
     Utils.objectEqual = objectEqual;
+    /**
+     * Get two object's unqiue properties
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @returns Unique properties
+     */
+    function objectKeys(obj1, obj2, ignoreFields = []) {
+        // All keys
+        const allKeys = [...Object.keys(obj1), ...Object.keys(obj2)].filter((item) => !ignoreFields.includes(item));
+        // Unique keys
+        return new Set(allKeys);
+    }
+    Utils.objectKeys = objectKeys;
+    /**
+     * Get the new object's updated fields contrast to the previous object
+     * @param objNew New object
+     * @param objPre Previous object
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Updated fields
+     */
+    function objectUpdated(objNew, objPrev, ignoreFields = [], strict = 1) {
+        // Fields
+        const fields = [];
+        // Unique keys
+        const keys = Utils.objectKeys(objNew, objPrev, ignoreFields);
+        for (const key of keys) {
+            // Values
+            const vNew = Reflect.get(objNew, key);
+            const vPrev = Reflect.get(objPrev, key);
+            if (!Utils.equals(vNew, vPrev, strict)) {
+                fields.push(key);
+            }
+        }
+        return fields;
+    }
+    Utils.objectUpdated = objectUpdated;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/mjs/StorageUtils.d.ts

@@ -21,9 +21,19 @@ export declare namespace StorageUtils {
      * @param defaultValue Default value
      */
     function getLocalData<T>(key: string, defaultValue: T): T;
+    /**
+     * Get local storage object data
+     * @param key Key name
+     */
+    function getLocalObject<T extends {}>(key: string): T | undefined;
     /**
      * Get session storage data
      * @param key Key name
      */
     function getSessionData<T>(key: string, defaultValue: T): T;
+    /**
+     * Get session storage object data
+     * @param key Key name
+     */
+    function getSessionObject<T extends {}>(key: string): T | undefined;
 }

package/lib/mjs/StorageUtils.js

@@ -48,6 +48,18 @@ export var StorageUtils;
         return Utils.parseString(data, defaultValue);
     }
     StorageUtils.getLocalData = getLocalData;
+    /**
+     * Get local storage object data
+     * @param key Key name
+     */
+    function getLocalObject(key) {
+        // Get storage
+        const data = localStorage.getItem(key);
+        if (data == null)
+            return undefined;
+        return JSON.parse(data);
+    }
+    StorageUtils.getLocalObject = getLocalObject;
     /**
      * Get session storage data
      * @param key Key name
@@ -59,4 +71,16 @@ export var StorageUtils;
         return Utils.parseString(data, defaultValue);
     }
     StorageUtils.getSessionData = getSessionData;
+    /**
+     * Get session storage object data
+     * @param key Key name
+     */
+    function getSessionObject(key) {
+        // Get storage
+        const data = sessionStorage.getItem(key);
+        if (data == null)
+            return undefined;
+        return JSON.parse(data);
+    }
+    StorageUtils.getSessionObject = getSessionObject;
 })(StorageUtils || (StorageUtils = {}));

package/lib/mjs/Utils.d.ts

@@ -35,6 +35,19 @@ declare global {
  * Utilities
  */
 export declare namespace Utils {
+    /**
+     * Base64 chars to number
+     * @param base64Chars Base64 chars
+     * @returns Number
+     */
+    function charsToNumber(base64Chars: string): number;
+    /**
+     * Two values equal
+     * @param v1 Value 1
+     * @param v2 Value 2
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     */
+    function equals(v1: unknown, v2: unknown, strict?: number): boolean;
     /**
      * Format inital character to lower case or upper case
      * @param input Input string
@@ -89,6 +102,12 @@ export declare namespace Utils {
      * Create a GUID
      */
     function newGUID(): string;
+    /**
+     * Number to base64 chars
+     * @param num Input number
+     * @returns Result
+     */
+    function numberToChars(num: number): string;
     /**
      * Test two objects are equal or not
      * @param obj1 Object 1
@@ -98,6 +117,23 @@ export declare namespace Utils {
      * @returns Result
      */
     function objectEqual(obj1: {}, obj2: {}, ignoreFields?: string[], strict?: number): boolean;
+    /**
+     * Get two object's unqiue properties
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @returns Unique properties
+     */
+    function objectKeys(obj1: {}, obj2: {}, ignoreFields?: string[]): Set<string>;
+    /**
+     * Get the new object's updated fields contrast to the previous object
+     * @param objNew New object
+     * @param objPre Previous object
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Updated fields
+     */
+    function objectUpdated(objNew: {}, objPrev: {}, ignoreFields?: string[], strict?: number): string[];
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/mjs/Utils.js

@@ -26,6 +26,43 @@ String.prototype.removeNonLetters = function () {
  */
 export var Utils;
 (function (Utils) {
+    /**
+     * Base64 chars to number
+     * @param base64Chars Base64 chars
+     * @returns Number
+     */
+    function charsToNumber(base64Chars) {
+        const chars = typeof Buffer === 'undefined'
+            ? [...atob(base64Chars)].map((char) => char.charCodeAt(0))
+            : [...Buffer.from(base64Chars, 'base64')];
+        return chars.reduce((previousValue, currentValue, currentIndex) => {
+            return previousValue + currentValue * Math.pow(128, currentIndex);
+        }, 0);
+    }
+    Utils.charsToNumber = charsToNumber;
+    /**
+     * Two values equal
+     * @param v1 Value 1
+     * @param v2 Value 2
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     */
+    function equals(v1, v2, strict = 1) {
+        // Null and undefined case
+        if (v1 == null || v2 == null) {
+            if (strict <= 1 && v1 == v2)
+                return true;
+            return v1 === v2;
+        }
+        // For array and object
+        if (typeof v1 === 'object')
+            return JSON.stringify(v1) === JSON.stringify(v2);
+        // 1 and '1' case
+        if (strict === 0)
+            return v1 == v2;
+        // Strict equal
+        return v1 === v2;
+    }
+    Utils.equals = equals;
     /**
      * Format inital character to lower case or upper case
      * @param input Input string
@@ -68,7 +105,7 @@ export var Utils;
             }
             if (initValue != null) {
                 const newValue = DataTypes.convert(value, initValue);
-                if (newValue === initValue) {
+                if (Utils.equals(newValue, initValue)) {
                     Reflect.deleteProperty(input, key);
                     return;
                 }
@@ -146,6 +183,27 @@ export var Utils;
         });
     }
     Utils.newGUID = newGUID;
+    /**
+     * Number to base64 chars
+     * @param num Input number
+     * @returns Result
+     */
+    function numberToChars(num) {
+        const codes = [];
+        while (num > 0) {
+            const code = num % 128;
+            codes.push(code);
+            num = (num - code) / 128;
+        }
+        if (typeof Buffer === 'undefined') {
+            return btoa(String.fromCharCode(...codes));
+        }
+        else {
+            const buffer = Buffer.from(codes);
+            return buffer.toString('base64');
+        }
+    }
+    Utils.numberToChars = numberToChars;
     /**
      * Test two objects are equal or not
      * @param obj1 Object 1
@@ -155,28 +213,56 @@ export var Utils;
      * @returns Result
      */
     function objectEqual(obj1, obj2, ignoreFields = [], strict = 1) {
-        // Keys
-        const keys = new Set([
-            ...Object.keys(obj1).filter((item) => !ignoreFields.includes(item)),
-            ...Object.keys(obj2).filter((item) => !ignoreFields.includes(item))
-        ]);
+        // Unique keys
+        const keys = Utils.objectKeys(obj1, obj2, ignoreFields);
         for (const key of keys) {
             // Values
             const v1 = Reflect.get(obj1, key);
             const v2 = Reflect.get(obj2, key);
-            // Null and undefined case
-            if (v1 == null && v2 == null && strict <= 1)
-                continue;
-            // 1 and '1' case
-            if (strict === 0 && v1 == v2)
-                continue;
-            // Strict equal
-            if (v1 !== v2)
+            if (!Utils.equals(v1, v2, strict))
                 return false;
         }
         return true;
     }
     Utils.objectEqual = objectEqual;
+    /**
+     * Get two object's unqiue properties
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @returns Unique properties
+     */
+    function objectKeys(obj1, obj2, ignoreFields = []) {
+        // All keys
+        const allKeys = [...Object.keys(obj1), ...Object.keys(obj2)].filter((item) => !ignoreFields.includes(item));
+        // Unique keys
+        return new Set(allKeys);
+    }
+    Utils.objectKeys = objectKeys;
+    /**
+     * Get the new object's updated fields contrast to the previous object
+     * @param objNew New object
+     * @param objPre Previous object
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Updated fields
+     */
+    function objectUpdated(objNew, objPrev, ignoreFields = [], strict = 1) {
+        // Fields
+        const fields = [];
+        // Unique keys
+        const keys = Utils.objectKeys(objNew, objPrev, ignoreFields);
+        for (const key of keys) {
+            // Values
+            const vNew = Reflect.get(objNew, key);
+            const vPrev = Reflect.get(objPrev, key);
+            if (!Utils.equals(vNew, vPrev, strict)) {
+                fields.push(key);
+            }
+        }
+        return fields;
+    }
+    Utils.objectUpdated = objectUpdated;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.0.74",
+    "version": "1.0.78",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -54,7 +54,7 @@
     "homepage": "https://github.com/ETSOO/Shared#readme",
     "dependencies": {},
     "devDependencies": {
-        "@types/jest": "^27.0.2",
+        "@types/jest": "^27.0.3",
         "@typescript-eslint/eslint-plugin": "^5.4.0",
         "@typescript-eslint/parser": "^5.4.0",
         "eslint": "^8.2.0",

package/src/StorageUtils.ts

@@ -57,6 +57,17 @@ export namespace StorageUtils {
         return Utils.parseString(data, defaultValue);
     }
 
+    /**
+     * Get local storage object data
+     * @param key Key name
+     */
+    export function getLocalObject<T extends {}>(key: string) {
+        // Get storage
+        const data = localStorage.getItem(key);
+        if (data == null) return undefined;
+        return <T>JSON.parse(data);
+    }
+
     /**
      * Get session storage data
      * @param key Key name
@@ -68,4 +79,15 @@ export namespace StorageUtils {
         // Return
         return Utils.parseString(data, defaultValue);
     }
+
+    /**
+     * Get session storage object data
+     * @param key Key name
+     */
+    export function getSessionObject<T extends {}>(key: string) {
+        // Get storage
+        const data = sessionStorage.getItem(key);
+        if (data == null) return undefined;
+        return <T>JSON.parse(data);
+    }
 }

package/src/Utils.ts

@@ -77,6 +77,46 @@ String.prototype.removeNonLetters = function (this: string) {
  * Utilities
  */
 export namespace Utils {
+    /**
+     * Base64 chars to number
+     * @param base64Chars Base64 chars
+     * @returns Number
+     */
+    export function charsToNumber(base64Chars: string) {
+        const chars =
+            typeof Buffer === 'undefined'
+                ? [...atob(base64Chars)].map((char) => char.charCodeAt(0))
+                : [...Buffer.from(base64Chars, 'base64')];
+
+        return chars.reduce((previousValue, currentValue, currentIndex) => {
+            return previousValue + currentValue * Math.pow(128, currentIndex);
+        }, 0);
+    }
+
+    /**
+     * Two values equal
+     * @param v1 Value 1
+     * @param v2 Value 2
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     */
+    export function equals(v1: unknown, v2: unknown, strict = 1) {
+        // Null and undefined case
+        if (v1 == null || v2 == null) {
+            if (strict <= 1 && v1 == v2) return true;
+            return v1 === v2;
+        }
+
+        // For array and object
+        if (typeof v1 === 'object')
+            return JSON.stringify(v1) === JSON.stringify(v2);
+
+        // 1 and '1' case
+        if (strict === 0) return v1 == v2;
+
+        // Strict equal
+        return v1 === v2;
+    }
+
     /**
      * Format inital character to lower case or upper case
      * @param input Input string
@@ -126,7 +166,7 @@ export namespace Utils {
 
             if (initValue != null) {
                 const newValue = DataTypes.convert(value, initValue);
-                if (newValue === initValue) {
+                if (Utils.equals(newValue, initValue)) {
                     Reflect.deleteProperty(input, key);
                     return;
                 }
@@ -218,6 +258,27 @@ export namespace Utils {
         });
     }
 
+    /**
+     * Number to base64 chars
+     * @param num Input number
+     * @returns Result
+     */
+    export function numberToChars(num: number) {
+        const codes = [];
+        while (num > 0) {
+            const code = num % 128;
+            codes.push(code);
+            num = (num - code) / 128;
+        }
+
+        if (typeof Buffer === 'undefined') {
+            return btoa(String.fromCharCode(...codes));
+        } else {
+            const buffer = Buffer.from(codes);
+            return buffer.toString('base64');
+        }
+    }
+
     /**
      * Test two objects are equal or not
      * @param obj1 Object 1
@@ -232,28 +293,72 @@ export namespace Utils {
         ignoreFields: string[] = [],
         strict = 1
     ) {
-        // Keys
-        const keys = new Set([
-            ...Object.keys(obj1).filter((item) => !ignoreFields.includes(item)),
-            ...Object.keys(obj2).filter((item) => !ignoreFields.includes(item))
-        ]);
+        // Unique keys
+        const keys = Utils.objectKeys(obj1, obj2, ignoreFields);
 
         for (const key of keys) {
             // Values
             const v1 = Reflect.get(obj1, key);
             const v2 = Reflect.get(obj2, key);
 
-            // Null and undefined case
-            if (v1 == null && v2 == null && strict <= 1) continue;
+            if (!Utils.equals(v1, v2, strict)) return false;
+        }
 
-            // 1 and '1' case
-            if (strict === 0 && v1 == v2) continue;
+        return true;
+    }
 
-            // Strict equal
-            if (v1 !== v2) return false;
+    /**
+     * Get two object's unqiue properties
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @returns Unique properties
+     */
+    export function objectKeys(
+        obj1: {},
+        obj2: {},
+        ignoreFields: string[] = []
+    ) {
+        // All keys
+        const allKeys = [...Object.keys(obj1), ...Object.keys(obj2)].filter(
+            (item) => !ignoreFields.includes(item)
+        );
+
+        // Unique keys
+        return new Set(allKeys);
+    }
+
+    /**
+     * Get the new object's updated fields contrast to the previous object
+     * @param objNew New object
+     * @param objPre Previous object
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Updated fields
+     */
+    export function objectUpdated(
+        objNew: {},
+        objPrev: {},
+        ignoreFields: string[] = [],
+        strict = 1
+    ) {
+        // Fields
+        const fields: string[] = [];
+
+        // Unique keys
+        const keys = Utils.objectKeys(objNew, objPrev, ignoreFields);
+
+        for (const key of keys) {
+            // Values
+            const vNew = Reflect.get(objNew, key);
+            const vPrev = Reflect.get(objPrev, key);
+
+            if (!Utils.equals(vNew, vPrev, strict)) {
+                fields.push(key);
+            }
         }
 
-        return true;
+        return fields;
     }
 
     /**