@etsoo/shared 1.1.89 → 1.1.91

package/README.md

@@ -272,6 +272,8 @@ String and other related utilities
 |replaceNullOrEmpty|Replace null or empty with default value|
 |setLabels|Set source with new labels|
 |snakeNameToWord|Snake name to works, 'snake_name' to 'Snake Name'|
+|sortByFavor|Sort array by favored values|
+|sortByFieldFavor|Sort array by favored field values|
 |trim|Trim chars|
 |trimEnd|Trim end chars|
 |trimStart|Trim start chars|

package/__tests__/Utils.ts

@@ -84,6 +84,28 @@ test('Tests for getDataChanges', () => {
     expect(input.amount).toBeUndefined();
 });
 
+test('Tests for object array getDataChanges', () => {
+    const input = {
+        id: 1,
+        ids: [1, 2],
+        items: [
+            { id: 1, label: 'a' },
+            { id: 2, label: 'b' }
+        ]
+    };
+    const initData = {
+        id: 1,
+        ids: [1],
+        items: [
+            { id: 1, label: 'a' },
+            { id: 2, label: 'b' }
+        ]
+    };
+    const fields = Utils.getDataChanges(input, initData);
+    expect(fields).toStrictEqual(['ids']);
+    expect(input.items).toBeUndefined();
+});
+
 test('Tests for exclude', () => {
     const options = [
         { id1: 1, name: 'a' },
@@ -228,6 +250,29 @@ test('Tests for getResult', () => {
     expect(valueResult).toBe(5);
 });
 
+test('Tests for sortByFavor', () => {
+    const items = [1, 2, 3, 4, 5, 6, 7];
+    expect(Utils.sortByFavor(items, [5, 1, 3])).toStrictEqual([
+        5, 1, 3, 2, 4, 6, 7
+    ]);
+});
+
+test('Tests for sortByFieldFavor', () => {
+    const options = [
+        { id: 'a', name: 'a1' },
+        { id: 'b', name: 'b2' },
+        { id: 'c', name: 'c3' },
+        { id: 'd', name: 'd4' },
+        { id: 'e', name: 'e5' },
+        { id: 'f', name: 'f6' }
+    ];
+    expect(
+        Utils.sortByFieldFavor(options, 'id', ['e', 'a', 'c']).map(
+            (option) => option.name
+        )
+    ).toStrictEqual(['e5', 'a1', 'c3', 'b2', 'd4', 'f6']);
+});
+
 test('Tests for trim', () => {
     expect(Utils.trim('//a/', '/')).toBe('a');
     expect(Utils.trim('/*/a/', ...['/', '*'])).toBe('a');

package/lib/cjs/DataTypes.js

@@ -99,7 +99,6 @@ var DataTypes;
      * @returns Converted value
      */
     function convert(input, target) {
-        var _a;
         // null or undefined
         if (input == null)
             return undefined;
@@ -107,7 +106,9 @@ var DataTypes;
         if (Array.isArray(target)) {
             // Element item
             const elementItem = target.length > 0 ? target[0] : input;
-            const elementType = (_a = getBasicNameByValue(elementItem, true)) !== null && _a !== void 0 ? _a : 'unknown[]';
+            const elementType = getBasicNameByValue(elementItem, true);
+            if (elementType == null)
+                return input;
             return convertByType(input, elementType);
         }
         // Target type
@@ -140,7 +141,7 @@ var DataTypes;
                     ? input.split(/,\s*/g) // Support comma separated array
                     : [input];
             // Element type
-            const elementType = (targetType.substr(0, targetType.length - 2));
+            const elementType = (targetType.slice(0, targetType.length - 2));
             // Convert type
             return (inputArray
                 .map((item) => convertByType(item, elementType))

package/lib/cjs/Utils.d.ts

@@ -254,6 +254,21 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Sort array by favored values
+     * @param items Items
+     * @param favored Favored values
+     * @returns Sorted array
+     */
+    const sortByFavor: <T>(items: T[], favored: T[]) => T[];
+    /**
+     * Sort array by favored field values
+     * @param items Items
+     * @param field Field to sort
+     * @param favored Favored field values
+     * @returns Sorted array
+     */
+    const sortByFieldFavor: <T, F extends keyof T>(items: T[], field: F, favored: T[F][]) => T[];
     /**
      * Trim chars
      * @param input Input string

package/lib/cjs/Utils.js

@@ -487,6 +487,42 @@ var Utils;
         }
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
+    function getSortValue(n1, n2) {
+        if (n1 === n2)
+            return 0;
+        if (n1 === -1)
+            return 1;
+        if (n2 === -1)
+            return -1;
+        return n1 - n2;
+    }
+    /**
+     * Sort array by favored values
+     * @param items Items
+     * @param favored Favored values
+     * @returns Sorted array
+     */
+    Utils.sortByFavor = (items, favored) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1);
+            const n2 = favored.indexOf(r2);
+            return getSortValue(n1, n2);
+        });
+    };
+    /**
+     * Sort array by favored field values
+     * @param items Items
+     * @param field Field to sort
+     * @param favored Favored field values
+     * @returns Sorted array
+     */
+    Utils.sortByFieldFavor = (items, field, favored) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1[field]);
+            const n2 = favored.indexOf(r2[field]);
+            return getSortValue(n1, n2);
+        });
+    };
     /**
      * Trim chars
      * @param input Input string

package/lib/mjs/DataTypes.js

@@ -96,7 +96,6 @@ export var DataTypes;
      * @returns Converted value
      */
     function convert(input, target) {
-        var _a;
         // null or undefined
         if (input == null)
             return undefined;
@@ -104,7 +103,9 @@ export var DataTypes;
         if (Array.isArray(target)) {
             // Element item
             const elementItem = target.length > 0 ? target[0] : input;
-            const elementType = (_a = getBasicNameByValue(elementItem, true)) !== null && _a !== void 0 ? _a : 'unknown[]';
+            const elementType = getBasicNameByValue(elementItem, true);
+            if (elementType == null)
+                return input;
             return convertByType(input, elementType);
         }
         // Target type
@@ -137,7 +138,7 @@ export var DataTypes;
                     ? input.split(/,\s*/g) // Support comma separated array
                     : [input];
             // Element type
-            const elementType = (targetType.substr(0, targetType.length - 2));
+            const elementType = (targetType.slice(0, targetType.length - 2));
             // Convert type
             return (inputArray
                 .map((item) => convertByType(item, elementType))

package/lib/mjs/Utils.d.ts

@@ -254,6 +254,21 @@ export declare namespace Utils {
      * @param firstOnly Only convert the first word to upper case
      */
     const snakeNameToWord: (name: string, firstOnly?: boolean) => string;
+    /**
+     * Sort array by favored values
+     * @param items Items
+     * @param favored Favored values
+     * @returns Sorted array
+     */
+    const sortByFavor: <T>(items: T[], favored: T[]) => T[];
+    /**
+     * Sort array by favored field values
+     * @param items Items
+     * @param field Field to sort
+     * @param favored Favored field values
+     * @returns Sorted array
+     */
+    const sortByFieldFavor: <T, F extends keyof T>(items: T[], field: F, favored: T[F][]) => T[];
     /**
      * Trim chars
      * @param input Input string

package/lib/mjs/Utils.js

@@ -481,6 +481,42 @@ export var Utils;
         }
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
+    function getSortValue(n1, n2) {
+        if (n1 === n2)
+            return 0;
+        if (n1 === -1)
+            return 1;
+        if (n2 === -1)
+            return -1;
+        return n1 - n2;
+    }
+    /**
+     * Sort array by favored values
+     * @param items Items
+     * @param favored Favored values
+     * @returns Sorted array
+     */
+    Utils.sortByFavor = (items, favored) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1);
+            const n2 = favored.indexOf(r2);
+            return getSortValue(n1, n2);
+        });
+    };
+    /**
+     * Sort array by favored field values
+     * @param items Items
+     * @param field Field to sort
+     * @param favored Favored field values
+     * @returns Sorted array
+     */
+    Utils.sortByFieldFavor = (items, field, favored) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1[field]);
+            const n2 = favored.indexOf(r2[field]);
+            return getSortValue(n1, n2);
+        });
+    };
     /**
      * Trim chars
      * @param input Input string

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.1.89",
+    "version": "1.1.91",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -54,10 +54,10 @@
     },
     "homepage": "https://github.com/ETSOO/Shared#readme",
     "devDependencies": {
-        "@types/jest": "^29.4.0",
+        "@types/jest": "^29.5.0",
         "@types/lodash.isequal": "^4.5.6",
-        "jest": "^29.4.3",
-        "jest-environment-jsdom": "^29.4.3",
+        "jest": "^29.5.0",
+        "jest-environment-jsdom": "^29.5.0",
         "ts-jest": "^29.0.5",
         "typescript": "^4.9.5"
     },

package/src/DataTypes.ts

@@ -356,9 +356,9 @@ export namespace DataTypes {
         if (Array.isArray(target)) {
             // Element item
             const elementItem = target.length > 0 ? target[0] : input;
-            const elementType =
-                getBasicNameByValue(elementItem, true) ?? 'unknown[]';
+            const elementType = getBasicNameByValue(elementItem, true);
 
+            if (elementType == null) return <T>input;
             return <any>convertByType(input, elementType);
         }
 
@@ -400,7 +400,7 @@ export namespace DataTypes {
 
             // Element type
             const elementType = <BasicNames>(
-                targetType.substr(0, targetType.length - 2)
+                targetType.slice(0, targetType.length - 2)
             );
 
             // Convert type

package/src/Utils.ts

@@ -661,6 +661,46 @@ export namespace Utils {
         return items.map((part) => part.formatInitial(true)).join(' ');
     };
 
+    function getSortValue(n1: number, n2: number) {
+        if (n1 === n2) return 0;
+        if (n1 === -1) return 1;
+        if (n2 === -1) return -1;
+        return n1 - n2;
+    }
+
+    /**
+     * Sort array by favored values
+     * @param items Items
+     * @param favored Favored values
+     * @returns Sorted array
+     */
+    export const sortByFavor = <T>(items: T[], favored: T[]) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1);
+            const n2 = favored.indexOf(r2);
+            return getSortValue(n1, n2);
+        });
+    };
+
+    /**
+     * Sort array by favored field values
+     * @param items Items
+     * @param field Field to sort
+     * @param favored Favored field values
+     * @returns Sorted array
+     */
+    export const sortByFieldFavor = <T, F extends keyof T>(
+        items: T[],
+        field: F,
+        favored: T[F][]
+    ) => {
+        return items.sort((r1, r2) => {
+            const n1 = favored.indexOf(r1[field]);
+            const n2 = favored.indexOf(r2[field]);
+            return getSortValue(n1, n2);
+        });
+    };
+
     /**
      * Trim chars
      * @param input Input string