ph-utils 0.8.1 → 0.8.3

package/lib/array.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 数组排序
+ * @param arr 待排序数组
+ * @param order 排序信息, asc - 升序, desc - 倒序
+ * @param orderKey 如果是个对象数组，按哪个字段排序
+ * @returns
+ */
+export declare function order<T>(arr: T[], order?: "asc" | "desc", orderKey?: string | null): T[];
+/**
+ * 返回一个所有集合交集的新集合
+ *
+ * 如果集合本身支持 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

@@ -0,0 +1,211 @@
+/**
+ * 数组排序
+ * @param arr 待排序数组
+ * @param order 排序信息, asc - 升序, desc - 倒序
+ * @param orderKey 如果是个对象数组，按哪个字段排序
+ * @returns
+ */
+export function order(arr, order = "asc", orderKey = null) {
+    const collator = new Intl.Collator();
+    return arr.sort((a, b) => {
+        let aValue = a, bValue = b;
+        if (typeof a === "object" && orderKey != null) {
+            // @ts-ignore
+            aValue = a[orderKey];
+            // @ts-ignore
+            bValue = b[orderKey];
+        }
+        let aGtb = -1;
+        if (typeof aValue === "string") {
+            aGtb = collator.compare(aValue, bValue);
+        }
+        else {
+            aGtb = aValue >= bValue ? 1 : -1;
+        }
+        return order === "asc" ? aGtb : -aGtb;
+    });
+}
+/**
+ * 返回所有集合交集的元素的新集合
+ */ 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 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.d.ts

@@ -37,7 +37,7 @@ export declare function endOf(date?: Date | string | number, unit?: string): Dat
  * @param pre 精度, s - 精确到秒, ms - 精确到毫秒, 默认: s
  * @returns
  */
-export declare function timeStamp(ctime?: Date | string | number, pre?: "s" | "ms"): number;
+export declare function timestamp(ctime?: Date | string | number, pre?: "s" | "ms"): number;
 /**
  * 日期加上指定时间后的日期
  * @param date 指定的日期
@@ -57,5 +57,10 @@ export declare function add(date: Date | string | number | null, num: number, un
  * @param num     需要添加的数字, 如果这个参数传递一个小于0的数字，则就是日期减去相应的数字
  * @param unit    需要添加的单位，date - 加减天数
  * @param fmt     如果传递了格式化的单位，则返回格式化后的日期, 格式化字符串 yyyy - 年, mm - 月, dd - 日, HH - 小时, MM - 分钟, ss - 秒
+ *
+ * #### 1. 前一天的日期字符串形式
+ * ```javascript
+ * add(new Date(), -1, 'Date', 'yyyy-mm-dd')
+ * ```
  */
 export declare function add(date: Date | string | number | null, num: number, unit: string, fmt: string): string;

package/lib/date.js

@@ -61,7 +61,7 @@ function getUnit(unit) {
  * @param month 月份, 如果不传, 则当前月的最后一天
  * @returns
  */
-function getLastDayOfYear(date, month) {
+function getLastDayOfMonth(date, month) {
     // 获取下个月的第一天
     const lastDate = new Date(date.getFullYear(), (month || date.getMonth()) + 1, 1);
     // 将下个月的第一天的日期减去一天，得到当前月的最后一天
@@ -154,7 +154,7 @@ export function dateOf(date, unit, isEnd = false) {
         let value = setValues[index];
         if (value === -2) {
             // 设置为某个月的最后一天的日期
-            value = getLastDayOfYear(clone);
+            value = getLastDayOfMonth(clone);
         }
         Date.prototype["set" + periods[index]].apply(clone, [
             setValues[index],
@@ -186,7 +186,7 @@ export function endOf(date, unit) {
  * @param pre 精度, s - 精确到秒, ms - 精确到毫秒, 默认: s
  * @returns
  */
-export function timeStamp(ctime, pre = "s") {
+export function timestamp(ctime, pre = "s") {
     let tm = parse(ctime).getTime();
     return pre === "s" ? Math.floor(tm / 1000) : tm;
 }

package/lib/dom.d.ts

@@ -98,4 +98,13 @@ export declare function queryHideNodeSize(hideNode: string | HTMLElement, parent
  * @param direction 检查的方向，默认为"horizontal"
  * @returns 如果元素在父元素的可视区域内，则返回true；否则返回false。
  */
-export declare function isVisible(el: HTMLElement, parent?: HTMLElement, direction?: string): boolean;
+export declare function isVisible(el: HTMLElement, parent?: HTMLElement | null | undefined, direction?: string): boolean;
+/**
+ * 判断当前设备是否为移动设备。
+ *
+ * 本函数通过检查用户代理字符串和屏幕尺寸来判断设备是否为移动设备。
+ * 这对于需要根据设备类型进行不同布局或功能调整的应用非常有用。
+ *
+ * @returns {boolean} 如果设备是移动设备，则返回true；否则返回false。
+ */
+export declare function isMobile(): boolean;

package/lib/dom.js

@@ -196,7 +196,10 @@ export function queryHideNodeSize(hideNode, parent = document.body) {
  * @param direction 检查的方向，默认为"horizontal"
  * @returns 如果元素在父元素的可视区域内，则返回true；否则返回false。
  */
-export function isVisible(el, parent = document.body, direction = "horizontal") {
+export function isVisible(el, parent = null, direction = "horizontal") {
+    if (parent == null) {
+        parent = el.offsetParent;
+    }
     // 获取父元素的边界信息
     const containerRect = parent.getBoundingClientRect();
     // 获取元素的边界信息
@@ -213,3 +216,24 @@ export function isVisible(el, parent = document.body, direction = "horizontal")
     // 判断元素是否完全在容器的可视区域内
     return elStart >= containerStart && elEnd <= containerEnd;
 }
+/**
+ * 判断当前设备是否为移动设备。
+ *
+ * 本函数通过检查用户代理字符串和屏幕尺寸来判断设备是否为移动设备。
+ * 这对于需要根据设备类型进行不同布局或功能调整的应用非常有用。
+ *
+ * @returns {boolean} 如果设备是移动设备，则返回true；否则返回false。
+ */
+export function isMobile() {
+    // 通过正则表达式匹配用户代理字符串，判断是否为移动设备
+    // 检查是否为移动设备
+    const isMobile = /Mobi|Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    // 获取窗口的 innerWidth 和 innerHeight，用于判断屏幕尺寸
+    // 获取屏幕宽度和高度
+    const screenWidth = window.innerWidth;
+    const screenHeight = window.innerHeight;
+    // 判断屏幕宽度或高度是否小于等于800或600，用于进一步确认是否为移动设备
+    const isScreenMobile = screenWidth <= 800 || screenHeight <= 600;
+    // 如果是移动设备或屏幕尺寸符合移动设备特征，则返回true
+    return isMobile || isScreenMobile;
+}

package/package.json

@@ -50,9 +50,17 @@
       "types": "./lib/color.d.ts",
       "import": "./lib/color.js"
     },
+    "./logger": {
+      "types": "./lib/logger.d.ts",
+      "import": "./lib/logger.js"
+    },
+    "./array": {
+      "types": "./lib/array.d.ts",
+      "import": "./lib/array.js"
+    },
     "./*": "./lib/*"
   },
-  "version": "0.8.1",
+  "version": "0.8.3",
   "type": "module",
   "repository": {
     "type": "git",