@etsoo/shared 1.2.52 → 1.2.55

package/lib/mjs/types/ErrorData.d.ts

@@ -1,4 +1,4 @@
-export type ErrorType = 'error' | 'unhandledrejection' | 'consoleWarn' | 'consoleError';
+export type ErrorType = "error" | "unhandledrejection" | "consoleWarn" | "consoleError";
 export type ErrorData = {
     type: ErrorType;
     subType?: string;

package/lib/mjs/types/EventClass.js

@@ -85,7 +85,7 @@ export class EventClass {
      * @param options Options
      */
     on(type, callback, options) {
-        if (typeof type === 'object') {
+        if (typeof type === "object") {
             for (const key in type) {
                 const item = key;
                 const itemCallback = type[item] ?? callback;

package/package.json

@@ -1,67 +1,65 @@
 {
-    "name": "@etsoo/shared",
-    "version": "1.2.52",
-    "description": "TypeScript shared utilities and functions",
-    "main": "lib/cjs/index.js",
-    "module": "lib/mjs/index.js",
-    "types": "lib/mjs/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./lib/mjs/index.js",
-            "require": "./lib/cjs/index.js"
-        }
-    },
-    "sideEffects": false,
-    "scripts": {
-        "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
-        "format": "prettier --write src/**/*.ts",
-        "lint": "eslint --ext .ts src/",
-        "test": "jest",
-        "test:debug": "node --inspect-brk ./node_modules/jest/bin/jest.js --runInBand"
-    },
-    "jest": {
-        "automock": false,
-        "testMatch": [
-            "<rootDir>/__tests__/**/*.ts"
-        ],
-        "testEnvironment": "jsdom",
-        "moduleFileExtensions": [
-            "js",
-            "ts",
-            "d.ts"
-        ],
-        "transform": {
-            ".+\\.ts$": "ts-jest"
-        }
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/ETSOO/Shared.git"
-    },
-    "keywords": [
-        "Shared utilities",
-        "TypeScript",
-        "ETSOO",
-        "SmartERP",
-        "司友云平台",
-        "青岛亿速思维",
-        "上海亿商"
+  "name": "@etsoo/shared",
+  "version": "1.2.55",
+  "description": "TypeScript shared utilities and functions",
+  "main": "lib/cjs/index.js",
+  "module": "lib/mjs/index.js",
+  "types": "lib/mjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/mjs/index.js",
+      "require": "./lib/cjs/index.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "test": "jest",
+    "test:debug": "node --inspect-brk ./node_modules/jest/bin/jest.js --runInBand"
+  },
+  "jest": {
+    "automock": false,
+    "testMatch": [
+      "<rootDir>/__tests__/**/*.ts"
+    ],
+    "testEnvironment": "jsdom",
+    "moduleFileExtensions": [
+      "js",
+      "ts",
+      "d.ts"
     ],
-    "author": "Garry Xiao",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/ETSOO/Shared/issues"
-    },
-    "homepage": "https://github.com/ETSOO/Shared#readme",
-    "devDependencies": {
-        "@types/jest": "^29.5.14",
-        "@types/lodash.isequal": "^4.5.8",
-        "jest": "^29.7.0",
-        "jest-environment-jsdom": "^29.7.0",
-        "ts-jest": "^29.2.5",
-        "typescript": "^5.6.3"
-    },
-    "dependencies": {
-        "lodash.isequal": "^4.5.0"
+    "transform": {
+      ".+\\.ts$": "ts-jest"
     }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ETSOO/Shared.git"
+  },
+  "keywords": [
+    "Shared utilities",
+    "TypeScript",
+    "ETSOO",
+    "SmartERP",
+    "司友云平台",
+    "青岛亿速思维",
+    "上海亿商"
+  ],
+  "author": "Garry Xiao",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ETSOO/Shared/issues"
+  },
+  "homepage": "https://github.com/ETSOO/Shared#readme",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/lodash.isequal": "^4.5.8",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "lodash.isequal": "^4.5.0"
+  }
 }

package/src/ActionResult.ts

@@ -1,31 +1,31 @@
-import { IActionResult } from './IActionResult';
+import { IActionResult } from "./IActionResult";
 
 /**
  * Action result
  */
 export class ActionResult {
-    /**
-     * Create a result from error
-     * @returns Action result interface
-     */
-    static create<D extends object = {}>(error: Error) {
-        // If the error has status / statusCode
-        const status =
-            'status' in error
-                ? error.status
-                : 'statusCode' in error
-                ? error.statusCode
-                : undefined;
+  /**
+   * Create a result from error
+   * @returns Action result interface
+   */
+  static create<D extends object = {}>(error: Error) {
+    // If the error has status / statusCode
+    const status =
+      "status" in error
+        ? error.status
+        : "statusCode" in error
+        ? error.statusCode
+        : undefined;
 
-        // Result
-        const result: IActionResult<D> = {
-            status: typeof status === 'number' ? status : undefined,
-            ok: false,
-            type: error.name,
-            title: error.message
-        };
+    // Result
+    const result: IActionResult<D> = {
+      status: typeof status === "number" ? status : undefined,
+      ok: false,
+      type: error.name,
+      title: error.message
+    };
 
-        // Return
-        return result;
-    }
+    // Return
+    return result;
+  }
 }

package/src/ArrayUtils.ts

@@ -1,223 +1,215 @@
-import isEqual from 'lodash.isequal';
-import { DataTypes } from './DataTypes';
+import isEqual from "lodash.isequal";
+import { DataTypes } from "./DataTypes";
 
 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>;
-
-        /**
-         * Get max number item or number item property
-         * @param field Object field to calculate
-         */
-        max(
-            ...field: T extends number
-                ? [undefined?]
-                : T extends object
-                ? [DataTypes.Keys<T, number>]
-                : [never]
-        ): number;
-
-        /**
-         * Get max field value item
-         * @param field Object field to calculate
-         */
-        maxItem(
-            field: T extends object ? DataTypes.Keys<T, number> : never
-        ): T | undefined;
-
-        /**
-         * Get min number item or number item property
-         * @param field Object field to calculate
-         */
-        min(
-            ...field: T extends number
-                ? [undefined?]
-                : T extends object
-                ? [DataTypes.Keys<T, number>]
-                : [never]
-        ): number;
-
-        /**
-         * Get min field value item
-         * @param field Object field to calculate
-         */
-        minItem(
-            field: T extends object ? DataTypes.Keys<T, number> : never
-        ): T | undefined;
-
-        /**
-         * Remove items by value or condition
-         * @param items Items to remove
-         */
-        remove(
-            ...items: (
-                | (T & (DataTypes.Basic | object))
-                | ((item: T) => boolean)
-            )[]
-        ): T[];
-
-        /**
-         * Sort by property
-         * @param property Property
-         * @param values Property values
-         */
-        sortByProperty<P extends keyof T>(property: P, values: T[P][]): T[];
-
-        /**
-         * Sum number items or number item properties
-         * @param field Object field to calculate
-         */
-        sum(
-            ...field: T extends number
-                ? [undefined?]
-                : T extends object
-                ? [DataTypes.Keys<T, number>]
-                : [never]
-        ): number;
-
-        /**
-         * Make all items are unique
-         * @param this Input array
-         */
-        toUnique(): Array<T>;
-    }
+  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>;
+
+    /**
+     * Get max number item or number item property
+     * @param field Object field to calculate
+     */
+    max(
+      ...field: T extends number
+        ? [undefined?]
+        : T extends object
+        ? [DataTypes.Keys<T, number>]
+        : [never]
+    ): number;
+
+    /**
+     * Get max field value item
+     * @param field Object field to calculate
+     */
+    maxItem(
+      field: T extends object ? DataTypes.Keys<T, number> : never
+    ): T | undefined;
+
+    /**
+     * Get min number item or number item property
+     * @param field Object field to calculate
+     */
+    min(
+      ...field: T extends number
+        ? [undefined?]
+        : T extends object
+        ? [DataTypes.Keys<T, number>]
+        : [never]
+    ): number;
+
+    /**
+     * Get min field value item
+     * @param field Object field to calculate
+     */
+    minItem(
+      field: T extends object ? DataTypes.Keys<T, number> : never
+    ): T | undefined;
+
+    /**
+     * Remove items by value or condition
+     * @param items Items to remove
+     */
+    remove(
+      ...items: ((T & (DataTypes.Basic | object)) | ((item: T) => boolean))[]
+    ): T[];
+
+    /**
+     * Sort by property
+     * @param property Property
+     * @param values Property values
+     */
+    sortByProperty<P extends keyof T>(property: P, values: T[P][]): T[];
+
+    /**
+     * Sum number items or number item properties
+     * @param field Object field to calculate
+     */
+    sum(
+      ...field: T extends number
+        ? [undefined?]
+        : T extends object
+        ? [DataTypes.Keys<T, number>]
+        : [never]
+    ): number;
+
+    /**
+     * 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
+  this: Array<T>,
+  target: Array<T>,
+  round?: boolean
 ) {
-    return ArrayUtils.differences(this, target, round);
+  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;
+  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.prototype.max = function <T>(
-    this: Array<T>,
-    field: T extends object ? DataTypes.Keys<T, number> : undefined
+  this: Array<T>,
+  field: T extends object ? DataTypes.Keys<T, number> : undefined
 ) {
-    if (field == null) {
-        return Math.max(...(this as Array<number>));
-    }
+  if (field == null) {
+    return Math.max(...(this as Array<number>));
+  }
 
-    return Math.max(...this.map((item) => item[field] as number));
+  return Math.max(...this.map((item) => item[field] as number));
 };
 
 Array.prototype.maxItem = function <T>(
-    this: Array<T>,
-    field: T extends object ? DataTypes.Keys<T, number> : never
+  this: Array<T>,
+  field: T extends object ? DataTypes.Keys<T, number> : never
 ) {
-    if (this.length === 0) return undefined;
+  if (this.length === 0) return undefined;
 
-    return this.reduce((prev, curr) =>
-        prev[field] > curr[field] ? prev : curr
-    );
+  return this.reduce((prev, curr) => (prev[field] > curr[field] ? prev : curr));
 };
 
 Array.prototype.min = function <T>(
-    this: Array<T>,
-    field: T extends object ? DataTypes.Keys<T, number> : undefined
+  this: Array<T>,
+  field: T extends object ? DataTypes.Keys<T, number> : undefined
 ) {
-    if (field == null) {
-        return Math.min(...(this as Array<number>));
-    }
+  if (field == null) {
+    return Math.min(...(this as Array<number>));
+  }
 
-    return Math.min(...this.map((item) => item[field] as number));
+  return Math.min(...this.map((item) => item[field] as number));
 };
 
 Array.prototype.minItem = function <T>(
-    this: Array<T>,
-    field: T extends object ? DataTypes.Keys<T, number> : never
+  this: Array<T>,
+  field: T extends object ? DataTypes.Keys<T, number> : never
 ) {
-    if (this.length === 0) return undefined;
+  if (this.length === 0) return undefined;
 
-    return this.reduce((prev, curr) =>
-        prev[field] < curr[field] ? prev : curr
-    );
+  return this.reduce((prev, curr) => (prev[field] < curr[field] ? prev : curr));
 };
 
 Array.prototype.remove = function <T>(
-    this: Array<T>,
-    ...items: ((T & (DataTypes.Basic | object)) | ((item: T) => boolean))[]
+  this: Array<T>,
+  ...items: ((T & (DataTypes.Basic | object)) | ((item: T) => boolean))[]
 ) {
-    const funs: ((item: T) => boolean)[] = [];
-    const results: T[] = [];
-    items.forEach((item) => {
-        if (typeof item === 'function') {
-            funs.push(item);
-        } else {
-            // For object items, should be removed by reference, not by value
-            const index = this.indexOf(item);
-            if (index >= 0) results.push(...this.splice(index, 1));
-        }
-    });
-
-    if (funs.length > 0) {
-        // Reduce check loops for performance
-        for (let i = this.length - 1; i >= 0; i--) {
-            if (funs.some((fun) => fun(this[i])))
-                results.push(...this.splice(i, 1));
-        }
+  const funs: ((item: T) => boolean)[] = [];
+  const results: T[] = [];
+  items.forEach((item) => {
+    if (typeof item === "function") {
+      funs.push(item);
+    } else {
+      // For object items, should be removed by reference, not by value
+      const index = this.indexOf(item);
+      if (index >= 0) results.push(...this.splice(index, 1));
     }
+  });
 
-    return results;
+  if (funs.length > 0) {
+    // Reduce check loops for performance
+    for (let i = this.length - 1; i >= 0; i--) {
+      if (funs.some((fun) => fun(this[i]))) results.push(...this.splice(i, 1));
+    }
+  }
+
+  return results;
 };
 
 Array.prototype.sortByProperty = function <T, P extends keyof T>(
-    this: Array<T>,
-    property: P,
-    values: T[P][]
+  this: Array<T>,
+  property: P,
+  values: T[P][]
 ) {
-    return this.sort((a, b) => {
-        const ai = values.indexOf(a[property]);
-        const bi = values.indexOf(b[property]);
-
-        if (ai === bi) return 0;
-        if (ai < 0 || bi < 0) return bi === 0 ? 1 : bi;
-        return ai - bi;
-    });
+  return this.sort((a, b) => {
+    const ai = values.indexOf(a[property]);
+    const bi = values.indexOf(b[property]);
+
+    if (ai === bi) return 0;
+    if (ai < 0 || bi < 0) return bi === 0 ? 1 : bi;
+    return ai - bi;
+  });
 };
 
 Array.prototype.sum = function <T>(
-    this: Array<T>,
-    field: T extends object ? DataTypes.Keys<T, number> : undefined
+  this: Array<T>,
+  field: T extends object ? DataTypes.Keys<T, number> : undefined
 ) {
-    if (field == null) {
-        return this.reduce((total, num) => total + (num as number), 0);
-    }
+  if (field == null) {
+    return this.reduce((total, num) => total + (num as number), 0);
+  }
 
-    return this.reduce((total, item) => total + (item[field] as number), 0);
+  return this.reduce((total, item) => total + (item[field] as number), 0);
 };
 
 /**
  * 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;
-    }
+  /**
+   * 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;
+  }
 }