ph-utils 0.8.2 → 0.8.3

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/package.json

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