@etsoo/shared 1.2.13 → 1.2.15

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__/DomUtils.ts

@@ -1,5 +1,6 @@
 import { DomUtils } from '../src/DomUtils';
 import { DataTypes } from '../src/DataTypes';
+import { DateUtils } from '../src/DateUtils';
 
 // Implement for tests
 class Rect implements DOMRect {
@@ -308,3 +309,20 @@ test('Tests for setFocus', () => {
     DomUtils.setFocus({ test: 'No content' }, container);
     expect(focus).toBeCalledTimes(2);
 });
+
+test('Tests for getInputValue', () => {
+    // Arrange
+    const input = document.createElement('input');
+    input.type = 'datetime-local';
+    input.value = DateUtils.formatForInput('2023-09-21T23:08', false) ?? '';
+
+    // Act
+    const result = DomUtils.getInputValue(input);
+
+    // Assert
+    expect(result).not.toBeUndefined();
+    expect(result instanceof Date).toBeTruthy();
+    if (result instanceof Date) {
+        expect(result.getDate()).toBe(21);
+    }
+});

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/DomUtils.d.ts

@@ -108,7 +108,7 @@ export declare namespace DomUtils {
      * @param input HTML input
      * @returns Result
      */
-    function getInputValue(input: HTMLInputElement): string | number | Date | null;
+    function getInputValue(input: HTMLInputElement): string | number | Date | null | undefined;
     /**
      * Get an unique key combined with current URL
      * @param key Key

package/lib/cjs/DomUtils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomUtils = void 0;
 /// <reference lib="dom" />
 const DataTypes_1 = require("./DataTypes");
+const DateUtils_1 = require("./DateUtils");
 if (typeof navigator === 'undefined') {
     // Test mock only
     global.navigator = { language: 'en-US' };
@@ -381,6 +382,7 @@ var DomUtils;
      * @returns Result
      */
     function getInputValue(input) {
+        var _a;
         const type = input.type;
         if (type === 'number' || type === 'range') {
             const num = input.valueAsNumber;
@@ -389,7 +391,7 @@ var DomUtils;
             return num;
         }
         else if (type === 'date' || type === 'datetime-local')
-            return input.valueAsDate;
+            return (_a = input.valueAsDate) !== null && _a !== void 0 ? _a : DateUtils_1.DateUtils.parse(input.value);
         return input.value;
     }
     DomUtils.getInputValue = getInputValue;

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/DomUtils.d.ts

@@ -108,7 +108,7 @@ export declare namespace DomUtils {
      * @param input HTML input
      * @returns Result
      */
-    function getInputValue(input: HTMLInputElement): string | number | Date | null;
+    function getInputValue(input: HTMLInputElement): string | number | Date | null | undefined;
     /**
      * Get an unique key combined with current URL
      * @param key Key

package/lib/mjs/DomUtils.js

@@ -1,5 +1,6 @@
 /// <reference lib="dom" />
 import { DataTypes } from './DataTypes';
+import { DateUtils } from './DateUtils';
 if (typeof navigator === 'undefined') {
     // Test mock only
     global.navigator = { language: 'en-US' };
@@ -378,6 +379,7 @@ export var DomUtils;
      * @returns Result
      */
     function getInputValue(input) {
+        var _a;
         const type = input.type;
         if (type === 'number' || type === 'range') {
             const num = input.valueAsNumber;
@@ -386,7 +388,7 @@ export var DomUtils;
             return num;
         }
         else if (type === 'date' || type === 'datetime-local')
-            return input.valueAsDate;
+            return (_a = input.valueAsDate) !== null && _a !== void 0 ? _a : DateUtils.parse(input.value);
         return input.value;
     }
     DomUtils.getInputValue = getInputValue;

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.15",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",

package/src/DomUtils.ts

@@ -1,5 +1,6 @@
 /// <reference lib="dom" />
 import { DataTypes } from './DataTypes';
+import { DateUtils } from './DateUtils';
 import { FormDataFieldValue, IFormData } from './types/FormData';
 
 if (typeof navigator === 'undefined') {
@@ -469,7 +470,7 @@ export namespace DomUtils {
             if (isNaN(num)) return null;
             return num;
         } else if (type === 'date' || type === 'datetime-local')
-            return input.valueAsDate;
+            return input.valueAsDate ?? DateUtils.parse(input.value);
         return input.value;
     }
 

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