@etsoo/shared 1.2.13 → 1.2.14

package/README.md

@@ -278,6 +278,7 @@ String and other related utilities
 |formatInitial|Format inital character to lower case or upper case|
 |formatString|Format string with parameters|
 |getDataChanges|Get data changed fields with input data updated|
+|getNestedValue|Get nested value from object|
 |getTimeZone|Get time zone|
 |hideData|Hide data|
 |hideEmail|Hide email data|
@@ -291,11 +292,13 @@ String and other related utilities
 |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|
+|parseJsonArray|Try to parse JSON input to array|
 |parsePath|Parse path similar with node.js path.parse|
 |parseString|Parse string (JSON) to specific type|
 |removeNonLetters|Remove non letters (0-9, a-z, A-Z)|
 |replaceNullOrEmpty|Replace null or empty with default value|
 |setLabels|Set source with new labels|
+|setNestedValue|Set nested value to object|
 |snakeNameToWord|Snake name to works, 'snake_name' to 'Snake Name'|
 |sortByFavor|Sort array by favored values|
 |sortByFieldFavor|Sort array by favored field values|

package/__tests__/Utils.ts

@@ -188,6 +188,12 @@ test('Tests for objectEqual', () => {
     expect(Utils.objectEqual(obj1, obj2, ['a'], 2)).toBeFalsy();
 });
 
+test('Tests for parseJsonArray', () => {
+    expect(Utils.parseJsonArray('[1, 3, "a"]', 0)).toBeUndefined();
+    expect(Utils.parseJsonArray('[1, 3, "a"]')).not.toBeUndefined();
+    expect(Utils.parseJsonArray('1, 3, 9')).not.toBeUndefined();
+});
+
 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], g: true };
@@ -230,6 +236,15 @@ test('Tests for mergeClasses', () => {
     expect(Utils.mergeClasses('a', '', 'b ', undefined, 'c')).toBe('a b c');
 });
 
+test('Tests for getNestedValue', () => {
+    const obj = { jsonData: { photoSize: [200, 100], supportResizing: true } };
+    expect(Utils.getNestedValue(obj, 'jsonData.supportResizing')).toBeTruthy();
+    expect(
+        Array.isArray(Utils.getNestedValue(obj, 'jsonData.photoSize'))
+    ).toBeTruthy();
+    expect(Utils.getNestedValue(obj, 'jsonData.unknown')).toBeUndefined();
+});
+
 test('Tests for getResult', () => {
     // Arrange
     type test = ((visible: boolean) => number) | number;
@@ -281,6 +296,16 @@ test('Tests for parsePath, Windows path', () => {
     expect(result.name).toBe('file');
 });
 
+test('Tests for setNestedValue', () => {
+    const obj = { jsonData: { photoSize: [200, 100], supportResizing: true } };
+
+    Utils.setNestedValue(obj, 'jsonData.supportResizing', false);
+    expect(obj.jsonData.supportResizing).toBeFalsy();
+
+    Utils.setNestedValue(obj, 'jsonData.newProperty.value', 125);
+    expect(Reflect.get((obj.jsonData as any).newProperty, 'value')).toBe(125);
+});
+
 test('Tests for sortByFavor', () => {
     const items = [1, 2, 3, 4, 5, 6, 7];
     expect(Utils.sortByFavor(items, [5, 1, 3])).toStrictEqual([

package/lib/cjs/Utils.d.ts

@@ -135,6 +135,13 @@ export declare namespace Utils {
      * @returns
      */
     function getDataChanges(input: object, initData: object, ignoreFields?: string[]): string[];
+    /**
+     * Get nested value from object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @returns Result
+     */
+    function getNestedValue(data: object, name: string): any;
     /**
      * Get input function or value result
      * @param input Input function or value
@@ -207,6 +214,13 @@ export declare namespace Utils {
      * @returns Updated fields
      */
     function objectUpdated(objNew: object, objPrev: object, ignoreFields?: string[], strict?: number): string[];
+    /**
+     * Try to parse JSON input to array
+     * @param input JSON input
+     * @param checkValue Type check value
+     * @returns Result
+     */
+    function parseJsonArray<T>(input: string, checkValue?: T): T[] | undefined;
     /**
      * Parse string (JSON) to specific type, no type conversion
      * For type conversion, please use DataTypes.convert
@@ -248,6 +262,13 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Set nested value to object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @param value Value
+     */
+    function setNestedValue(data: object, name: string, value: unknown): void;
     /**
      * Parse path similar with node.js path.parse
      * @param path Input path

package/lib/cjs/Utils.js

@@ -239,6 +239,36 @@ var Utils;
         return changes;
     }
     Utils.getDataChanges = getDataChanges;
+    /**
+     * Get nested value from object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @returns Result
+     */
+    function getNestedValue(data, name) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1) {
+            return Reflect.get(data, name);
+        }
+        else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+                if (i + 1 === len) {
+                    return Reflect.get(curr, property);
+                }
+                else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        return undefined;
+                    }
+                    curr = p;
+                }
+            }
+        }
+    }
+    Utils.getNestedValue = getNestedValue;
     /**
      * Get input function or value result
      * @param input Input function or value
@@ -389,6 +419,30 @@ var Utils;
         return fields;
     }
     Utils.objectUpdated = objectUpdated;
+    /**
+     * Try to parse JSON input to array
+     * @param input JSON input
+     * @param checkValue Type check value
+     * @returns Result
+     */
+    function parseJsonArray(input, checkValue) {
+        try {
+            if (!input.startsWith('['))
+                input = `[${input}]`;
+            const array = JSON.parse(input);
+            const type = typeof checkValue;
+            if (Array.isArray(array) &&
+                (checkValue == null ||
+                    !array.some((item) => typeof item !== type))) {
+                return array;
+            }
+        }
+        catch (e) {
+            console.log('parseJsonArray', input, e);
+        }
+        return;
+    }
+    Utils.parseJsonArray = parseJsonArray;
     /**
      * Parse string (JSON) to specific type, no type conversion
      * When return type depends on parameter value, uses function overloading, otherwise uses conditional type
@@ -484,6 +538,36 @@ var Utils;
             return -1;
         return n1 - n2;
     }
+    /**
+     * Set nested value to object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @param value Value
+     */
+    function setNestedValue(data, name, value) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1)
+            Reflect.set(data, name, value);
+        else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+                if (i + 1 === len) {
+                    Reflect.set(curr, property, value);
+                }
+                else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        p = {};
+                        Reflect.set(curr, property, p);
+                    }
+                    curr = p;
+                }
+            }
+        }
+    }
+    Utils.setNestedValue = setNestedValue;
     /**
      * Parse path similar with node.js path.parse
      * @param path Input path

package/lib/mjs/Utils.d.ts

@@ -135,6 +135,13 @@ export declare namespace Utils {
      * @returns
      */
     function getDataChanges(input: object, initData: object, ignoreFields?: string[]): string[];
+    /**
+     * Get nested value from object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @returns Result
+     */
+    function getNestedValue(data: object, name: string): any;
     /**
      * Get input function or value result
      * @param input Input function or value
@@ -207,6 +214,13 @@ export declare namespace Utils {
      * @returns Updated fields
      */
     function objectUpdated(objNew: object, objPrev: object, ignoreFields?: string[], strict?: number): string[];
+    /**
+     * Try to parse JSON input to array
+     * @param input JSON input
+     * @param checkValue Type check value
+     * @returns Result
+     */
+    function parseJsonArray<T>(input: string, checkValue?: T): T[] | undefined;
     /**
      * Parse string (JSON) to specific type, no type conversion
      * For type conversion, please use DataTypes.convert
@@ -248,6 +262,13 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Set nested value to object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @param value Value
+     */
+    function setNestedValue(data: object, name: string, value: unknown): void;
     /**
      * Parse path similar with node.js path.parse
      * @param path Input path

package/lib/mjs/Utils.js

@@ -233,6 +233,36 @@ export var Utils;
         return changes;
     }
     Utils.getDataChanges = getDataChanges;
+    /**
+     * Get nested value from object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @returns Result
+     */
+    function getNestedValue(data, name) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1) {
+            return Reflect.get(data, name);
+        }
+        else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+                if (i + 1 === len) {
+                    return Reflect.get(curr, property);
+                }
+                else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        return undefined;
+                    }
+                    curr = p;
+                }
+            }
+        }
+    }
+    Utils.getNestedValue = getNestedValue;
     /**
      * Get input function or value result
      * @param input Input function or value
@@ -383,6 +413,30 @@ export var Utils;
         return fields;
     }
     Utils.objectUpdated = objectUpdated;
+    /**
+     * Try to parse JSON input to array
+     * @param input JSON input
+     * @param checkValue Type check value
+     * @returns Result
+     */
+    function parseJsonArray(input, checkValue) {
+        try {
+            if (!input.startsWith('['))
+                input = `[${input}]`;
+            const array = JSON.parse(input);
+            const type = typeof checkValue;
+            if (Array.isArray(array) &&
+                (checkValue == null ||
+                    !array.some((item) => typeof item !== type))) {
+                return array;
+            }
+        }
+        catch (e) {
+            console.log('parseJsonArray', input, e);
+        }
+        return;
+    }
+    Utils.parseJsonArray = parseJsonArray;
     /**
      * Parse string (JSON) to specific type, no type conversion
      * When return type depends on parameter value, uses function overloading, otherwise uses conditional type
@@ -478,6 +532,36 @@ export var Utils;
             return -1;
         return n1 - n2;
     }
+    /**
+     * Set nested value to object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @param value Value
+     */
+    function setNestedValue(data, name, value) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1)
+            Reflect.set(data, name, value);
+        else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+                if (i + 1 === len) {
+                    Reflect.set(curr, property, value);
+                }
+                else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        p = {};
+                        Reflect.set(curr, property, p);
+                    }
+                    curr = p;
+                }
+            }
+        }
+    }
+    Utils.setNestedValue = setNestedValue;
     /**
      * Parse path similar with node.js path.parse
      * @param path Input path

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.2.13",
+    "version": "1.2.14",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",

package/src/Utils.ts

@@ -352,6 +352,36 @@ export namespace Utils {
         return changes;
     }
 
+    /**
+     * Get nested value from object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @returns Result
+     */
+    export function getNestedValue(data: object, name: string) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1) {
+            return Reflect.get(data, name);
+        } else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+
+                if (i + 1 === len) {
+                    return Reflect.get(curr, property);
+                } else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        return undefined;
+                    }
+
+                    curr = p;
+                }
+            }
+        }
+    }
+
     /**
      * Get input function or value result
      * @param input Input function or value
@@ -541,6 +571,33 @@ export namespace Utils {
         return fields;
     }
 
+    /**
+     * Try to parse JSON input to array
+     * @param input JSON input
+     * @param checkValue Type check value
+     * @returns Result
+     */
+    export function parseJsonArray<T>(
+        input: string,
+        checkValue?: T
+    ): T[] | undefined {
+        try {
+            if (!input.startsWith('[')) input = `[${input}]`;
+            const array = JSON.parse(input);
+            const type = typeof checkValue;
+            if (
+                Array.isArray(array) &&
+                (checkValue == null ||
+                    !array.some((item) => typeof item !== type))
+            ) {
+                return array;
+            }
+        } catch (e) {
+            console.log('parseJsonArray', input, e);
+        }
+        return;
+    }
+
     /**
      * Parse string (JSON) to specific type, no type conversion
      * For type conversion, please use DataTypes.convert
@@ -673,6 +730,36 @@ export namespace Utils {
         return n1 - n2;
     }
 
+    /**
+     * Set nested value to object
+     * @param data Data
+     * @param name Field name, support property chain like 'jsonData.logSize'
+     * @param value Value
+     */
+    export function setNestedValue(data: object, name: string, value: unknown) {
+        const properties = name.split('.');
+        const len = properties.length;
+        if (len === 1) Reflect.set(data, name, value);
+        else {
+            let curr = data;
+            for (let i = 0; i < len; i++) {
+                const property = properties[i];
+
+                if (i + 1 === len) {
+                    Reflect.set(curr, property, value);
+                } else {
+                    let p = Reflect.get(curr, property);
+                    if (p == null) {
+                        p = {};
+                        Reflect.set(curr, property, p);
+                    }
+
+                    curr = p;
+                }
+            }
+        }
+    }
+
     /**
      * Parse path similar with node.js path.parse
      * @param path Input path