ph-utils 0.8.2 → 0.8.4

package/lib/array.d.ts

@@ -7,8 +7,73 @@
  */
 export declare function order<T>(arr: T[], order?: "asc" | "desc", orderKey?: string | null): T[];
 /**
- * 多个数组取交集, 通常用于字符串或者数字数组
- * @param arrs 待取交集的多个数组
- * @returns
+ * 返回一个所有集合交集的新集合
+ *
+ * 如果集合本身支持 intersection, 则调用原生 intersection 函数
+ *
+ * @param arrs
+ *
+ * @returns 新集合中的元素在传入的所有集合中同时存在
+ */
+export declare function intersection<T>(...arrs: Set<T>[]): Set<T>;
+/**
+ * 返回一个所有列表交集的新列表
+ *
+ * @param arrs
+ *
+ * @returns 新列表中的元素在传入的所有列表中同时存在
  */
 export declare function intersection<T>(...arrs: T[][]): T[];
+/**
+ * 返回一个包含第一个集合中的元素但不包含后续给定集合中元素的新集合
+ *
+ * 如果集合本身支持 difference 方法，则调用原生 difference 方法
+ *
+ * @param arrs 集合列表
+ *
+ * @returns
+ */
+export declare function difference<T>(...arrs: Set<T>[]): Set<T>;
+/**
+ * 返回一个包含第一个列表中的元素但不包含后续给定列表中元素的新列表
+ *
+ * @param arrs 二维列表
+ *
+ * @returns
+ */
+export declare function difference<T>(...arrs: T[][]): T[];
+/**
+ * 返回多个集合的并集, 如果支持 union，则调用原生 union
+ *
+ * @param arrs
+ *
+ * @returns 一个包含所有给定集合的所有元素的新集合
+ */
+export declare function union<T>(...arrs: Set<T>[]): Set<T>;
+export declare function union<T>(...arrs: T[][]): T[];
+export declare function symmetricDifference<T>(...arrs: Set<T>[]): Set<T>;
+export declare function symmetricDifference<T>(...arrs: T[][]): T[];
+/**
+ * 返回一个布尔值，指示此集合中的所有元素是否都在给定的集合中。
+ * @param a1
+ * @param a2
+ * @returns
+ */
+export declare function isSubsetOf<T>(a1: T[] | Set<T>, a2: T[] | Set<T>): any;
+/**
+ * 返回一个布尔值，指示给定集合中的所有元素是否都在此集合中。
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export declare function isSupersetOf<T>(arr1: T[] | Set<T>, arr2: T[] | Set<T>): any;
+/**
+ * 返回一个布尔值，指示此集合是否与给定集合没有公共元素。
+ *
+ * 判断两个集合是否有交集, 也可以通过 intersection(arr1, arr2).length 判断
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export declare function isDisjointFrom<T>(arr1: T[] | Set<T>, arr2: T[] | Set<T>): any;

package/lib/array.js

@@ -26,10 +26,186 @@ export function order(arr, order = "asc", orderKey = null) {
     });
 }
 /**
- * 多个数组取交集, 通常用于字符串或者数字数组
- * @param arrs 待取交集的多个数组
+ * 返回所有集合交集的元素的新集合
+ */ export function intersection(...arrs) {
+    return arrs.reduce((acc, cur) => {
+        if (cur instanceof Set) {
+            //@ts-ignore
+            if (cur.intersection != null) {
+                //@ts-ignore
+                return acc.intersection(cur);
+            }
+            else {
+                const res = new Set();
+                for (const value of acc) {
+                    if (cur.has(value)) {
+                        res.add(value);
+                    }
+                }
+                return res;
+            }
+        }
+        else {
+            return acc.filter((x) => cur.includes(x));
+        }
+    });
+}
+/**
+ * 返回一个包含第一个集合中的元素但不包含后续给定集合中元素的新集合
+ * @param arrs 新集合
  * @returns
  */
-export function intersection(...arrs) {
-    return arrs.reduce((acc, cur) => acc.filter((x) => cur.includes(x)));
+export function difference(...arrs) {
+    return arrs.reduce((acc, cur) => {
+        if (acc instanceof Set) {
+            //@ts-ignore
+            if (acc.difference != null) {
+                //@ts-ignore
+                return acc.difference(cur);
+            }
+            else {
+                const res = new Set();
+                for (const value of acc) {
+                    if (!cur.has(value)) {
+                        res.add(value);
+                    }
+                }
+                return res;
+            }
+        }
+        else {
+            const res = [];
+            for (const value of acc) {
+                if (!cur.includes(value)) {
+                    res.push(value);
+                }
+            }
+            return res;
+        }
+    });
+}
+export function union(...arrs) {
+    return arrs.reduce((acc, cur) => {
+        if (cur instanceof Set) {
+            //@ts-ignore
+            if (cur.union != null) {
+                //@ts-ignore
+                return acc.union(cur);
+            }
+            return new Set([...acc, ...cur]);
+        }
+        else {
+            return [...acc, ...cur];
+        }
+    });
+}
+/**
+ * 对称差: 返回一个包含此集合或给定集合中的元素的新集合，但不包含同时存在于这两个集合中的元素。
+ * @param arrs
+ * @returns
+ */
+export function symmetricDifference(...arrs) {
+    return arrs.reduce((acc, cur) => {
+        if (cur instanceof Set) {
+            //@ts-ignore
+            if (cur.symmetricDifference != null) {
+                //@ts-ignore
+                return acc.symmetricDifference(cur);
+            }
+            const res = new Set();
+            for (const item of acc) {
+                if (!cur.has(item)) {
+                    res.add(item);
+                }
+            }
+            for (const item of cur) {
+                if (!acc.has(item)) {
+                    res.add(item);
+                }
+            }
+            return res;
+        }
+        const res = [];
+        for (const item of acc) {
+            if (!cur.includes(item)) {
+                res.push(item);
+            }
+        }
+        for (const item of cur) {
+            if (!acc.includes(item)) {
+                res.push(item);
+            }
+        }
+        return res;
+    });
+}
+/**
+ * 返回一个布尔值，指示此集合中的所有元素是否都在给定的集合中。
+ * @param a1
+ * @param a2
+ * @returns
+ */
+export function isSubsetOf(a1, a2) {
+    //@ts-ignore
+    if (a1 instanceof Set && a1.isSubsetOf != null) {
+        //@ts-ignore
+        return a1.isSubsetOf(a2);
+    }
+    let is = true;
+    for (const item of a1) {
+        if (a2 instanceof Set) {
+            if (!a2.has(item)) {
+                is = false;
+                break;
+            }
+        }
+        else {
+            if (!a2.includes(item)) {
+                is = false;
+                break;
+            }
+        }
+    }
+    return is;
+}
+/**
+ * 返回一个布尔值，指示给定集合中的所有元素是否都在此集合中。
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export function isSupersetOf(arr1, arr2) {
+    return isSubsetOf(arr2, arr1);
+}
+/**
+ * 返回一个布尔值，指示此集合是否与给定集合没有公共元素。
+ *
+ * 判断两个集合是否有交集, 也可以通过 intersection(arr1, arr2).length 判断
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export function isDisjointFrom(arr1, arr2) {
+    //@ts-ignore
+    if (arr1 instanceof Set && arr1.isDisjointFrom != null) {
+        //@ts-ignore
+        return arr1.isDisjointFrom(arr2);
+    }
+    let is = true;
+    for (const item of arr1) {
+        if (arr2 instanceof Set) {
+            if (arr2.has(item)) {
+                is = false;
+                break;
+            }
+        }
+        else {
+            if (arr2.includes(item)) {
+                is = false;
+                break;
+            }
+        }
+    }
+    return is;
 }

package/lib/color.d.ts

@@ -39,8 +39,15 @@ export declare function toHex(color: any): string;
 /**
  * 调整给定颜色深[darken]浅[lighten]
  * @param color - 输入的颜色，可以是任意颜色表示方式
- * @param level - 调整深浅级别, 可以是小数
- * @param light - 控制调整的方向。如果为true，[lighten] 变浅，如果为false，[darken] 变深。
+ * @param level - 调整深浅级别, 可以是小数。默认: 1
+ * @param light - 控制调整的方向。如果为true，[lighten] 变浅，如果为false，[darken] 变深。默认: true
+ *
+ * #### 1. 颜色变浅
+ *
+ * ```
+ * adjust('#4998f4', 3, true)
+ * ```
+ *
  * @returns 返回调整后颜色的十六进制字符串表示。
  */
 export declare function adjust(color: any, level?: number, light?: boolean): string;

package/lib/color.js

@@ -272,8 +272,15 @@ export function toHex(color) {
 /**
  * 调整给定颜色深[darken]浅[lighten]
  * @param color - 输入的颜色，可以是任意颜色表示方式
- * @param level - 调整深浅级别, 可以是小数
- * @param light - 控制调整的方向。如果为true，[lighten] 变浅，如果为false，[darken] 变深。
+ * @param level - 调整深浅级别, 可以是小数。默认: 1
+ * @param light - 控制调整的方向。如果为true，[lighten] 变浅，如果为false，[darken] 变深。默认: true
+ *
+ * #### 1. 颜色变浅
+ *
+ * ```
+ * adjust('#4998f4', 3, true)
+ * ```
+ *
  * @returns 返回调整后颜色的十六进制字符串表示。
  */
 export function adjust(color, level = 1, light = true) {

package/lib/date.js

@@ -116,8 +116,6 @@ export function format(date, pattern = "yyyy-mm-dd HH:MM:ss") {
 export function parse(date) {
     if (date == null)
         return new Date();
-    if (date instanceof Date)
-        return date;
     if (typeof date === "string" && !/Z$/i.test(date)) {
         const d = date.match(REGEX_PARSE);
         if (d) {
@@ -127,7 +125,7 @@ export function parse(date) {
     if (typeof date === "number") {
         return new Date(date <= 9999999999 ? date * 1000 : date);
     }
-    return new Date();
+    return new Date(date);
 }
 /**
  * 设置日期的开始或者结束的点

package/lib/index.d.ts

@@ -29,37 +29,55 @@ export declare function isNumeric(str: string, numericParam?: {
  */
 export declare function isBoolean(str: string): boolean;
 /** 生成随机数的选项 */
-interface RandomConfig {
+interface RandomStringOption {
     /** 生成指定长度的随机字符串 */
-    length?: number;
+    length: number;
     /** 是否包含英文字母, 默认为: true */
     hasLetter?: boolean;
     /** 生成纯数字的随机数时, 首位是否允许为 0, 默认为: true */
     firstIsZero?: boolean;
+}
+interface RangeRandomOption {
     /** 配合 max 生成 [min~max] 之间的随机数 */
-    min?: number;
+    min: number;
     /** 配合 min 生成 [min~max] 之间的随机数 */
-    max?: number;
+    max: number;
     /** 生成的随机数，是否包含 max, 默认: false */
     hasEnd?: boolean;
     /** 生成的随机数是否是整数, 默认: true */
     isInteger?: boolean;
 }
 /**
- * 生成随机数
- *  1. 生成指定长度的随机数
- *  2. 生成介于 [min, max] 之间的随机数
- * @param opts 生成随机数的配置
+ * 生成指定长度的随机数
+ *
+ * @param len - 生成的随机数长度
  *
  * @example <caption>1. 生成指定长度的随机字符串</caption>
  * random(1); // 长度为 1 的随机字符串
+ */
+export declare function random(len: number): string;
+/**
+ * 生成介于 [min, max] 之间的随机数
  *
- * @example <caption>2. 生成纯数字且不能为0长度为1的随机字符</caption>
- * random({ length: 1, hasLetter: false, firstIsZero: false })
+ * @param option 配置项
+ * @param option.min 生成介于 [min, max] 之间的随机数
+ * @param option.max 生成介于 [min, max] 之间的随机数
+ * @param option.hasEnd 生成的随机数，是否包含 max, 默认: false
+ * @param option.isInteger 生成的随机数是否是整数, 默认: true
+ */
+export declare function random(option: RangeRandomOption): number;
+/**
+ * 生成指定长度随机数
  *
- * @returns
+ * @param option 配置项
+ * @param option.length 生成的随机数长度
+ * @param option.hasLetter 是否包含英文字母, 默认为: true
+ * @param option.firstIsZero 生成纯数字的随机数时, 首位是否允许为 0, 默认为: true
+ *
+ * @example <caption>2. 生成纯数字且首位不能为0长度为1的随机字符</caption>
+ * random({ length: 1, hasLetter: false, firstIsZero: false })
  */
-export declare function random(opts: number | RandomConfig): string | number;
+export declare function random(option: RandomStringOption): string;
 /**
  * 带有错误名称标记的错误类型
  */

package/lib/index.js

@@ -53,20 +53,6 @@ export function isNumeric(str, numericParam) {
 export function isBoolean(str) {
     return ["true", "false"].indexOf(str) >= 0;
 }
-/**
- * 生成随机数
- *  1. 生成指定长度的随机数
- *  2. 生成介于 [min, max] 之间的随机数
- * @param opts 生成随机数的配置
- *
- * @example <caption>1. 生成指定长度的随机字符串</caption>
- * random(1); // 长度为 1 的随机字符串
- *
- * @example <caption>2. 生成纯数字且不能为0长度为1的随机字符</caption>
- * random({ length: 1, hasLetter: false, firstIsZero: false })
- *
- * @returns
- */
 export function random(opts) {
     if (typeof opts === "object" && opts.min != null && opts.max != null) {
         const randomNum = Math.random();
@@ -79,13 +65,13 @@ export function random(opts) {
         if (typeof opts === "object" && opts.length == null) {
             throw new Error("random_length_cannot_null");
         }
-        const len = typeof opts === "object" ? opts.length : opts;
+        let len = typeof opts === "object" ? opts.length : opts;
         /* 生成指定长度的随机数 */
         let chars = RANDOM_CHARS;
         if (typeof opts === "object" && opts.hasLetter === false) {
             chars = NUMBER_RANDOM_CHARTS;
         }
-        const resRandom = Array.from({ length: len }, () => chars.charAt(random({ min: 0, max: 9, hasEnd: true }))).join("");
+        const resRandom = Array.from({ length: len }, () => chars.charAt(random({ min: 0, max: chars.length - 1, hasEnd: true }))).join("");
         if (typeof opts === "object" &&
             opts.firstIsZero === false &&
             resRandom.indexOf("0") === 0) {

package/lib/storage.d.ts

@@ -11,8 +11,8 @@ interface StorageSetOption {
  * 存储值到 Storage 中
  * @param key 设置的 key
  * @param value 设置的值
- * @param storage session 或 local
- * @param expire 数据有效期, 单位秒, 默认: -1 - 永久存储
+ * @param [option.storage] session 或 local, 默认: session
+ * @param [option.expire] 数据有效期, 单位秒, 默认: -1 - 永久存储
  */
 export declare function set(key: string, value: any, option?: StorageSetOption): void;
 /**
@@ -37,8 +37,8 @@ interface StorageQueryOption {
  * 从 Storage 中取出数据
  * @param key 保存时的 key
  * @param defaultValue 没有数据时的默认值
- * @param delete 是否在取出后，删除数据，默认：false - 取出后删除数据
- * @param storage 使用的 Storage ，可以是 localStorage、sessionStorage
+ * @param [option.delete] 是否在取出后，删除数据，默认：false - 取出后删除数据
+ * @param [option.storage] 使用的 Storage ，可以是 localStorage、sessionStorage, 默认: localStorage、sessionStorage
  * @returns Storage 中 key 对应的数据
  */
 export declare function get<T>(key: string, defaultValue?: T, option?: StorageQueryOption): T;

package/lib/storage.js

@@ -5,8 +5,8 @@ function getStorage(storage = "session") {
  * 存储值到 Storage 中
  * @param key 设置的 key
  * @param value 设置的值
- * @param storage session 或 local
- * @param expire 数据有效期, 单位秒, 默认: -1 - 永久存储
+ * @param [option.storage] session 或 local, 默认: session
+ * @param [option.expire] 数据有效期, 单位秒, 默认: -1 - 永久存储
  */
 export function set(key, value, option) {
     const opts = {
@@ -40,8 +40,8 @@ export function remove(key, storage) {
  * 从 Storage 中取出数据
  * @param key 保存时的 key
  * @param defaultValue 没有数据时的默认值
- * @param delete 是否在取出后，删除数据，默认：false - 取出后删除数据
- * @param storage 使用的 Storage ，可以是 localStorage、sessionStorage
+ * @param [option.delete] 是否在取出后，删除数据，默认：false - 取出后删除数据
+ * @param [option.storage] 使用的 Storage ，可以是 localStorage、sessionStorage, 默认: localStorage、sessionStorage
  * @returns Storage 中 key 对应的数据
  */
 export function get(key, defaultValue, option) {

package/package.json

@@ -60,7 +60,7 @@
     },
     "./*": "./lib/*"
   },
-  "version": "0.8.2",
+  "version": "0.8.4",
   "type": "module",
   "repository": {
     "type": "git",