@etsoo/shared 1.0.56 → 1.0.60

package/README.md

@@ -132,6 +132,7 @@ String and other related utilities
 |mergeFormData|Merge form data to primary one|
 |mergeClasses|Merge class names|
 |newGUID|Create a GUID|
+|objectEqual|Test two objects are equal or not|
 |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__/DomUtils.ts

@@ -133,17 +133,27 @@ test('Tests for dataAs', () => {
     formData.append('price', '34.25');
     formData.append('options', '1,2,3,4');
     formData.append('memo', 'Memo');
+    formData.append('email', 'a@b');
+    formData.append('email', 'c@d');
+    formData.append('code', '123');
+    formData.append('code', '456');
 
     const data = DomUtils.dataAs(formData, {
         id: 'number',
         name: 'string',
         price: 'number',
-        options: 'number[]'
+        options: 'number[]',
+        email: 'string[]',
+        code: 'number[]'
     });
 
     expect(data.id).toStrictEqual(1234);
     expect(data.options?.length).toStrictEqual(4);
     expect(data.options![0]).toStrictEqual(1);
+
+    expect(data.email).toEqual(['a@b', 'c@d']);
+    expect(data.code?.length).toStrictEqual(2);
+    expect(data.code).toEqual([123, 456]);
     expect(data).not.toHaveProperty('memo', 'Memo');
 
     const keepSourceData = DomUtils.dataAs(

package/__tests__/Utils.ts

@@ -23,6 +23,13 @@ test('Tests for getDataChanges', () => {
     expect(input.amount).toBeUndefined();
 });
 
+test('Tests for formatString', () => {
+    const template = '{0} is first item, {1} is second item, {0} repeat';
+    const result = 'aa is first item, bb is second item, aa repeat';
+    expect(Utils.formatString(template, 'aa', 'bb')).toBe(result);
+    expect(template.format('aa', 'bb')).toBe(result);
+});
+
 test('Tests for formatLowerLetter', () => {
     expect(Utils.formatLowerLetter('HelloWorld')).toBe('helloWorld');
 });
@@ -51,6 +58,15 @@ test('Tests for removeNonLetters', () => {
     expect(Utils.removeNonLetters('1234-5678@abc.')).toBe('12345678abc');
 });
 
+test('Tests for objectEqual', () => {
+    const obj1 = { a: 1, b: 'abc', c: true, d: null };
+    const obj2 = { a: '1', b: 'abc', c: true };
+    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 parseString', () => {
     expect(Utils.parseString('test', '')).toBe('test');
     expect(Utils.parseString('true', false)).toBe(true);

package/lib/cjs/DomUtils.js

@@ -94,9 +94,7 @@ var DomUtils;
         // Properties
         const properties = Object.keys(template);
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(isFormData(source) ? formDataToObject(source) : source);
         for (const [key, value] of entries) {
             // Is included or keepSource
             const property = (_a = properties.find((p) => p.localeCompare(key, 'en', { sensitivity: 'base' }) ===

package/lib/cjs/Utils.d.ts

@@ -1,4 +1,15 @@
 import { DataTypes } from './DataTypes';
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         * @returns Result
+         */
+        format(this: string, ...parameters: string[]): string;
+    }
+}
 /**
  * Utilities
  */
@@ -8,6 +19,13 @@ export declare namespace Utils {
      * @param word Word
      */
     function formatLowerLetter(word: string): string;
+    /**
+     * Format string
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
+     */
+    function formatString(template: string, ...parameters: string[]): string;
     /**
      * Format word's first letter to upper case
      * @param word Word
@@ -41,6 +59,15 @@ export declare namespace Utils {
      * Create a GUID
      */
     function newGUID(): string;
+    /**
+     * Test two objects are equal or not
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Result
+     */
+    function objectEqual(obj1: {}, obj2: {}, ignoreFields?: string[], strict?: number): boolean;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/cjs/Utils.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
 const DataTypes_1 = require("./DataTypes");
+String.prototype.format = function (...parameters) {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
 /**
  * Utilities
  */
@@ -15,6 +22,16 @@ var Utils;
         return word.charAt(0).toLowerCase() + word.slice(1);
     }
     Utils.formatLowerLetter = formatLowerLetter;
+    /**
+     * Format string
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
+     */
+    function formatString(template, ...parameters) {
+        return template.format(...parameters);
+    }
+    Utils.formatString = formatString;
     /**
      * Format word's first letter to upper case
      * @param word Word
@@ -98,6 +115,37 @@ var Utils;
         });
     }
     Utils.newGUID = newGUID;
+    /**
+     * Test two objects are equal or not
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @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))
+        ]);
+        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)
+                return false;
+        }
+        return true;
+    }
+    Utils.objectEqual = objectEqual;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/mjs/DomUtils.js

@@ -91,9 +91,7 @@ export var DomUtils;
         // Properties
         const properties = Object.keys(template);
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(isFormData(source) ? formDataToObject(source) : source);
         for (const [key, value] of entries) {
             // Is included or keepSource
             const property = (_a = properties.find((p) => p.localeCompare(key, 'en', { sensitivity: 'base' }) ===

package/lib/mjs/Utils.d.ts

@@ -1,4 +1,15 @@
 import { DataTypes } from './DataTypes';
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         * @returns Result
+         */
+        format(this: string, ...parameters: string[]): string;
+    }
+}
 /**
  * Utilities
  */
@@ -8,6 +19,13 @@ export declare namespace Utils {
      * @param word Word
      */
     function formatLowerLetter(word: string): string;
+    /**
+     * Format string
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
+     */
+    function formatString(template: string, ...parameters: string[]): string;
     /**
      * Format word's first letter to upper case
      * @param word Word
@@ -41,6 +59,15 @@ export declare namespace Utils {
      * Create a GUID
      */
     function newGUID(): string;
+    /**
+     * Test two objects are equal or not
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Result
+     */
+    function objectEqual(obj1: {}, obj2: {}, ignoreFields?: string[], strict?: number): boolean;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/lib/mjs/Utils.js

@@ -1,4 +1,11 @@
 import { DataTypes } from './DataTypes';
+String.prototype.format = function (...parameters) {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
 /**
  * Utilities
  */
@@ -12,6 +19,16 @@ export var Utils;
         return word.charAt(0).toLowerCase() + word.slice(1);
     }
     Utils.formatLowerLetter = formatLowerLetter;
+    /**
+     * Format string
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
+     */
+    function formatString(template, ...parameters) {
+        return template.format(...parameters);
+    }
+    Utils.formatString = formatString;
     /**
      * Format word's first letter to upper case
      * @param word Word
@@ -95,6 +112,37 @@ export var Utils;
         });
     }
     Utils.newGUID = newGUID;
+    /**
+     * Test two objects are equal or not
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @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))
+        ]);
+        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)
+                return false;
+        }
+        return true;
+    }
+    Utils.objectEqual = objectEqual;
     /**
      * Parse string (JSON) to specific type
      * @param input Input string

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.0.56",
+    "version": "1.0.60",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -24,6 +24,11 @@
             "<rootDir>/__tests__/**/*.ts"
         ],
         "testEnvironment": "jsdom",
+        "moduleFileExtensions": [
+            "js",
+            "ts",
+            "d.ts"
+        ],
         "transform": {
             ".+\\.ts$": "ts-jest"
         }

package/src/DomUtils.ts

@@ -108,9 +108,9 @@ export namespace DomUtils {
         const properties = Object.keys(template);
 
         // Entries
-        const entries = isFormData(source)
-            ? source.entries()
-            : Object.entries(source);
+        const entries = Object.entries(
+            isFormData(source) ? formDataToObject(source) : source
+        );
 
         for (const [key, value] of entries) {
             // Is included or keepSource

package/src/Utils.ts

@@ -1,5 +1,28 @@
 import { DataTypes } from './DataTypes';
 
+declare global {
+    interface String {
+        /**
+         * Format string
+         * @param this Template
+         * @param parameters Parameters to fill the template
+         * @returns Result
+         */
+        format(this: string, ...parameters: string[]): string;
+    }
+}
+
+String.prototype.format = function (
+    this: string,
+    ...parameters: string[]
+): string {
+    let template = this;
+    parameters.forEach((value, index) => {
+        template = template.replace(new RegExp(`\\{${index}\\}`, 'g'), value);
+    });
+    return template;
+};
+
 /**
  * Utilities
  */
@@ -12,6 +35,16 @@ export namespace Utils {
         return word.charAt(0).toLowerCase() + word.slice(1);
     }
 
+    /**
+     * Format string
+     * @param template Template with {0}, {1}, ...
+     * @param parameters Parameters to fill the template
+     * @returns Result
+     */
+    export function formatString(template: string, ...parameters: string[]) {
+        return template.format(...parameters);
+    }
+
     /**
      * Format word's first letter to upper case
      * @param word Word
@@ -115,6 +148,44 @@ export namespace Utils {
         });
     }
 
+    /**
+     * Test two objects are equal or not
+     * @param obj1 Object 1
+     * @param obj2 Object 2
+     * @param ignoreFields Ignored fields
+     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @returns Result
+     */
+    export function objectEqual(
+        obj1: {},
+        obj2: {},
+        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))
+        ]);
+
+        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) return false;
+        }
+
+        return true;
+    }
+
     /**
      * Parse string (JSON) to specific type
      * @param input Input string