@etsoo/shared 1.1.92 → 1.1.94

package/README.md

@@ -96,8 +96,16 @@ ETSOO Extended abstract history class
 |pushState|Adds an entry to the history stack|
 |replaceState|Modifies the current history entry|
 
+## ArrayUtils
+Array related utilities
+
+|Name|Description|
+|---:|---|
+|differences|Array 1 items do not exist in Array 2 or reverse match|
+|toUnique|Make all items are unique|
+
 ## DataTypes
-Data type definitions and type safe functions. ListItemType and ListItemType1 are sugar types.
+Data type definitions and type safe functions. ListItemType, ListItemType1 and ListItemType2 are sugar types.
 
 |Name|Description|
 |---:|---|
@@ -244,7 +252,6 @@ String and other related utilities
 |Name|Description|
 |---:|---|
 |addBlankItem|Add blank item to collection|
-|arrayDifferences|Array 1 items do not exist in Array 2 or reverse match|
 |charsToNumber|Base64 chars to number|
 |containChinese|Check the input string contains Chinese character or not|
 |correctTypes|Correct object's property value type|

package/__tests__/ArrayUtils.ts

@@ -0,0 +1,22 @@
+import { ArrayUtils } from '../src/ArrayUtils';
+
+test('Tests for simple type toUnique', () => {
+    const result = [1, 1, 3, 5, 5].toUnique();
+    expect(result).toStrictEqual([1, 3, 5]);
+});
+
+test('Tests for object type toUnique', () => {
+    const result = [
+        { id: 1, label: 'a' },
+        { id: 2, label: 'b' },
+        { id: 2, label: 'b' }
+    ].toUnique();
+    expect(result.length).toBe(2);
+});
+
+test('Tests for differences', () => {
+    const a1 = ['a', 'b', 'c', 'e'];
+    const a2 = ['a', 'c', 'd'];
+    expect(ArrayUtils.differences(a1, a2)).toEqual(['b', 'e']);
+    expect(ArrayUtils.differences(a1, a2, true)).toEqual(['b', 'e', 'd']);
+});

package/__tests__/Utils.ts

@@ -21,13 +21,6 @@ test('Tests for containChinese', () => {
     expect('ぁ-ん'.containJapanese()).toBeTruthy();
 });
 
-test('Tests for arrayDifferences', () => {
-    const a1 = ['a', 'b', 'c', 'e'];
-    const a2 = ['a', 'c', 'd'];
-    expect(Utils.arrayDifferences(a1, a2)).toEqual(['b', 'e']);
-    expect(Utils.arrayDifferences(a1, a2, true)).toEqual(['b', 'e', 'd']);
-});
-
 test('Tests for correctTypes', () => {
     const input = {
         id: '1',

package/lib/cjs/ArrayUtils.d.ts

@@ -0,0 +1,27 @@
+declare global {
+    interface Array<T> {
+        /**
+         * Items do not exist in target array or reverse match
+         * @param target Target array
+         * @param round A round for both matches
+         */
+        different(target: Array<T>, round?: boolean): Array<T>;
+        /**
+         * Make all items are unique
+         * @param this Input array
+         */
+        toUnique(): Array<T>;
+    }
+}
+/**
+ * Array Utilities
+ */
+export declare namespace ArrayUtils {
+    /**
+     * Array 1 items do not exist in Array 2 or reverse match
+     * @param a1 Array 1
+     * @param a2 Array 2
+     * @param round A round for both matches
+     */
+    function differences<T>(a1: T[], a2: T[], round?: boolean): T[];
+}

package/lib/cjs/ArrayUtils.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtils = void 0;
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+Array.prototype.different = function (target, round) {
+    return ArrayUtils.differences(this, target, round);
+};
+Array.prototype.toUnique = function () {
+    if (this.length === 0 || typeof this[0] !== 'object')
+        return Array.from(new Set(this));
+    const newArray = [];
+    this.forEach((item) => {
+        if (newArray.some((newItem) => (0, lodash_isequal_1.default)(item, newItem)))
+            return;
+        newArray.push(item);
+    });
+    return newArray;
+};
+/**
+ * Array Utilities
+ */
+var ArrayUtils;
+(function (ArrayUtils) {
+    /**
+     * Array 1 items do not exist in Array 2 or reverse match
+     * @param a1 Array 1
+     * @param a2 Array 2
+     * @param round A round for both matches
+     */
+    function differences(a1, a2, round) {
+        const diff = a1.filter((x) => !a2.includes(x));
+        if (round)
+            return [...diff, ...a2.filter((x) => !a1.includes(x))];
+        return diff;
+    }
+    ArrayUtils.differences = differences;
+})(ArrayUtils = exports.ArrayUtils || (exports.ArrayUtils = {}));

package/lib/cjs/DataTypes.d.ts

@@ -395,6 +395,16 @@ export type ListType = DataTypes.IdLabelItem<number>;
  * List item with string id type
  */
 export type ListType1 = DataTypes.IdLabelItem<string>;
+/**
+ * List item with compatible id and name / label
+ */
+export type ListType2 = {
+    id: DataTypes.IdType;
+} & ({
+    label: string;
+} | {
+    name: string;
+});
 /**
  * Id default type
  */

package/lib/cjs/Utils.d.ts

@@ -72,13 +72,6 @@ export declare namespace Utils {
      * @param blankLabel Blank label, default is ---
      */
     function addBlankItem<T extends object>(options: T[], idField?: string | keyof T, labelField?: unknown, blankLabel?: string): T[];
-    /**
-     * Array 1 items do not exist in Array 2 or reverse match
-     * @param a1 Array 1
-     * @param a2 Array 2
-     * @param round A round for both matches
-     */
-    function arrayDifferences<T>(a1: T[], a2: T[], round?: boolean): T[];
     /**
      * Base64 chars to number
      * @param base64Chars Base64 chars

package/lib/cjs/Utils.js

@@ -98,19 +98,6 @@ var Utils;
         return options;
     }
     Utils.addBlankItem = addBlankItem;
-    /**
-     * Array 1 items do not exist in Array 2 or reverse match
-     * @param a1 Array 1
-     * @param a2 Array 2
-     * @param round A round for both matches
-     */
-    function arrayDifferences(a1, a2, round) {
-        const diff = a1.filter((x) => !a2.includes(x));
-        if (round)
-            return [...diff, ...a2.filter((x) => !a1.includes(x))];
-        return diff;
-    }
-    Utils.arrayDifferences = arrayDifferences;
     /**
      * Base64 chars to number
      * @param base64Chars Base64 chars

package/lib/cjs/index.d.ts

@@ -7,6 +7,7 @@ export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './ActionResult';
+export * from './ArrayUtils';
 export * from './DataTypes';
 export * from './ColorUtils';
 export * from './DateUtils';

package/lib/cjs/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./types/FormData"), exports);
 __exportStar(require("./storage/IStorage"), exports);
 __exportStar(require("./storage/WindowStorage"), exports);
 __exportStar(require("./ActionResult"), exports);
+__exportStar(require("./ArrayUtils"), exports);
 __exportStar(require("./DataTypes"), exports);
 __exportStar(require("./ColorUtils"), exports);
 __exportStar(require("./DateUtils"), exports);

package/lib/mjs/ArrayUtils.d.ts

@@ -0,0 +1,27 @@
+declare global {
+    interface Array<T> {
+        /**
+         * Items do not exist in target array or reverse match
+         * @param target Target array
+         * @param round A round for both matches
+         */
+        different(target: Array<T>, round?: boolean): Array<T>;
+        /**
+         * Make all items are unique
+         * @param this Input array
+         */
+        toUnique(): Array<T>;
+    }
+}
+/**
+ * Array Utilities
+ */
+export declare namespace ArrayUtils {
+    /**
+     * Array 1 items do not exist in Array 2 or reverse match
+     * @param a1 Array 1
+     * @param a2 Array 2
+     * @param round A round for both matches
+     */
+    function differences<T>(a1: T[], a2: T[], round?: boolean): T[];
+}

package/lib/mjs/ArrayUtils.js

@@ -0,0 +1,34 @@
+import isEqual from 'lodash.isequal';
+Array.prototype.different = function (target, round) {
+    return ArrayUtils.differences(this, target, round);
+};
+Array.prototype.toUnique = function () {
+    if (this.length === 0 || typeof this[0] !== 'object')
+        return Array.from(new Set(this));
+    const newArray = [];
+    this.forEach((item) => {
+        if (newArray.some((newItem) => isEqual(item, newItem)))
+            return;
+        newArray.push(item);
+    });
+    return newArray;
+};
+/**
+ * Array Utilities
+ */
+export var ArrayUtils;
+(function (ArrayUtils) {
+    /**
+     * Array 1 items do not exist in Array 2 or reverse match
+     * @param a1 Array 1
+     * @param a2 Array 2
+     * @param round A round for both matches
+     */
+    function differences(a1, a2, round) {
+        const diff = a1.filter((x) => !a2.includes(x));
+        if (round)
+            return [...diff, ...a2.filter((x) => !a1.includes(x))];
+        return diff;
+    }
+    ArrayUtils.differences = differences;
+})(ArrayUtils || (ArrayUtils = {}));

package/lib/mjs/DataTypes.d.ts

@@ -395,6 +395,16 @@ export type ListType = DataTypes.IdLabelItem<number>;
  * List item with string id type
  */
 export type ListType1 = DataTypes.IdLabelItem<string>;
+/**
+ * List item with compatible id and name / label
+ */
+export type ListType2 = {
+    id: DataTypes.IdType;
+} & ({
+    label: string;
+} | {
+    name: string;
+});
 /**
  * Id default type
  */

package/lib/mjs/Utils.d.ts

@@ -72,13 +72,6 @@ export declare namespace Utils {
      * @param blankLabel Blank label, default is ---
      */
     function addBlankItem<T extends object>(options: T[], idField?: string | keyof T, labelField?: unknown, blankLabel?: string): T[];
-    /**
-     * Array 1 items do not exist in Array 2 or reverse match
-     * @param a1 Array 1
-     * @param a2 Array 2
-     * @param round A round for both matches
-     */
-    function arrayDifferences<T>(a1: T[], a2: T[], round?: boolean): T[];
     /**
      * Base64 chars to number
      * @param base64Chars Base64 chars

package/lib/mjs/Utils.js

@@ -92,19 +92,6 @@ export var Utils;
         return options;
     }
     Utils.addBlankItem = addBlankItem;
-    /**
-     * Array 1 items do not exist in Array 2 or reverse match
-     * @param a1 Array 1
-     * @param a2 Array 2
-     * @param round A round for both matches
-     */
-    function arrayDifferences(a1, a2, round) {
-        const diff = a1.filter((x) => !a2.includes(x));
-        if (round)
-            return [...diff, ...a2.filter((x) => !a1.includes(x))];
-        return diff;
-    }
-    Utils.arrayDifferences = arrayDifferences;
     /**
      * Base64 chars to number
      * @param base64Chars Base64 chars

package/lib/mjs/index.d.ts

@@ -7,6 +7,7 @@ export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './ActionResult';
+export * from './ArrayUtils';
 export * from './DataTypes';
 export * from './ColorUtils';
 export * from './DateUtils';

package/lib/mjs/index.js

@@ -7,6 +7,7 @@ export * from './types/FormData';
 export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 export * from './ActionResult';
+export * from './ArrayUtils';
 export * from './DataTypes';
 export * from './ColorUtils';
 export * from './DateUtils';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.1.92",
+    "version": "1.1.94",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -59,7 +59,7 @@
         "jest": "^29.5.0",
         "jest-environment-jsdom": "^29.5.0",
         "ts-jest": "^29.0.5",
-        "typescript": "^4.9.5"
+        "typescript": "^5.0.2"
     },
     "dependencies": {
         "lodash.isequal": "^4.5.0"

package/src/ArrayUtils.ts

@@ -0,0 +1,55 @@
+import isEqual from 'lodash.isequal';
+
+declare global {
+    interface Array<T> {
+        /**
+         * Items do not exist in target array or reverse match
+         * @param target Target array
+         * @param round A round for both matches
+         */
+        different(target: Array<T>, round?: boolean): Array<T>;
+
+        /**
+         * Make all items are unique
+         * @param this Input array
+         */
+        toUnique(): Array<T>;
+    }
+}
+
+Array.prototype.different = function <T>(
+    this: Array<T>,
+    target: Array<T>,
+    round?: boolean
+) {
+    return ArrayUtils.differences(this, target, round);
+};
+
+Array.prototype.toUnique = function <T>(this: Array<T>) {
+    if (this.length === 0 || typeof this[0] !== 'object')
+        return Array.from(new Set(this));
+
+    const newArray: T[] = [];
+    this.forEach((item) => {
+        if (newArray.some((newItem) => isEqual(item, newItem))) return;
+        newArray.push(item);
+    });
+    return newArray;
+};
+
+/**
+ * Array Utilities
+ */
+export namespace ArrayUtils {
+    /**
+     * Array 1 items do not exist in Array 2 or reverse match
+     * @param a1 Array 1
+     * @param a2 Array 2
+     * @param round A round for both matches
+     */
+    export function differences<T>(a1: T[], a2: T[], round?: boolean) {
+        const diff = a1.filter((x) => !a2.includes(x));
+        if (round) return [...diff, ...a2.filter((x) => !a1.includes(x))];
+        return diff;
+    }
+}

package/src/DataTypes.ts

@@ -754,6 +754,13 @@ export type ListType = DataTypes.IdLabelItem<number>;
  */
 export type ListType1 = DataTypes.IdLabelItem<string>;
 
+/**
+ * List item with compatible id and name / label
+ */
+export type ListType2 = {
+    id: DataTypes.IdType;
+} & ({ label: string } | { name: string });
+
 /**
  * Id default type
  */

package/src/Utils.ts

@@ -179,18 +179,6 @@ export namespace Utils {
         return options;
     }
 
-    /**
-     * Array 1 items do not exist in Array 2 or reverse match
-     * @param a1 Array 1
-     * @param a2 Array 2
-     * @param round A round for both matches
-     */
-    export function arrayDifferences<T>(a1: T[], a2: T[], round?: boolean) {
-        const diff = a1.filter((x) => !a2.includes(x));
-        if (round) return [...diff, ...a2.filter((x) => !a1.includes(x))];
-        return diff;
-    }
-
     /**
      * Base64 chars to number
      * @param base64Chars Base64 chars

package/src/index.ts

@@ -9,6 +9,7 @@ export * from './storage/IStorage';
 export * from './storage/WindowStorage';
 
 export * from './ActionResult';
+export * from './ArrayUtils';
 export * from './DataTypes';
 export * from './ColorUtils';
 export * from './DateUtils';