ph-utils 0.15.4 → 0.16.0

package/lib/color.d.ts

@@ -9,6 +9,7 @@ type HSVColorObject = {
     s: number;
     v: number;
 };
+type ColorType = string | RGBColorObject | HSVColorObject;
 /**
  * 将输入的颜色值转换为RGB对象格式。
  *
@@ -16,14 +17,14 @@ type HSVColorObject = {
  * @returns 返回一个包含r、g、b和a（透明度）属性的RGB对象。
  * @throws 如果输入的字符串不是有效的颜色表示，则抛出错误。
  */
-export declare function toRgb(color: any): RGBColorObject;
+export declare function toRgb(color: ColorType): RGBColorObject;
 /**
  * 将颜色转换为HSV颜色模型。
  *
  * @param color - 字符串或者RGB对象
  * @returns 返回一个包含h、s、v属性的对象，代表HSV颜色值，其中h是色相（取值范围0到360），s是饱和度（取值范围0到1），v是明度（取值范围0到1）。
  */
-export declare function toHsv(color: any): HSVColorObject;
+export declare function toHsv(color: ColorType): HSVColorObject;
 /**
  * 将RGB颜色对象转换为十六进制颜色字符串。
  * @param rgb - 包含红色(r), 绿色(g), 蓝色(b)成分的对象。
@@ -35,7 +36,7 @@ export declare function rgbToHex(rgb: RGBColorObject): string;
  * @param color - 颜色, 可以 rgb(0,0,0),rgba(0,0,0,0)字符串, 也可以是 rgb、hsv对象
  * @returns 返回颜色的十六进制字符串，例如"#FF0000"
  */
-export declare function toHex(color: any): string;
+export declare function toHex(color: ColorType): string;
 /**
  * 调整给定颜色深[darken]浅[lighten]
  * @param color - 输入的颜色，可以是任意颜色表示方式
@@ -50,5 +51,5 @@ export declare function toHex(color: any): string;
  *
  * @returns 返回调整后颜色的十六进制字符串表示。
  */
-export declare function adjust(color: any, level?: number, light?: boolean): string;
+export declare function adjust(color: ColorType, level?: number, light?: boolean): string;
 export {};

package/lib/color.js

@@ -265,7 +265,6 @@ export function toHex(color) {
         if (hexRegex.test(color)) {
             return color;
         }
-        return rgbToHex(toRgb(color));
     }
     return rgbToHex(toRgb(color));
 }

package/lib/dom.d.ts

@@ -48,7 +48,7 @@ export declare function $$(tag: string, option?: {
  * @param dom - 可选的父级 DOM 元素，默认为当前文档。
  * @returns 返回匹配的第一个 HTMLElement，如果没有找到则返回 undefined。
  */
-export declare function $one(selector: string | HTMLElement, dom?: DocumentContext): HTMLElement | undefined;
+export declare function $one(selector: string | HTMLElement, dom?: DocumentContext): HTMLElement | null;
 /**
  * 为节点添加 class
  * @param {HTMLElement} elem 待添加 class 的节点
@@ -120,7 +120,7 @@ export declare function html(element: HTMLElement, htmlstr?: string): string | u
  */
 export declare function text(element: HTMLElement, textstr?: string): string | null | undefined;
 export declare function iterate<T>(elems: T[], fn: (el: T, index: number) => any): void;
-export declare function iterate(elems: NodeList | HTMLCollection, fn: (el: HTMLElement, index: number) => any): void;
+export declare function iterate(elems: NodeList | HTMLCollection | NodeListOf<HTMLElement>, fn: (el: HTMLElement, index: number) => any): void;
 /**
  * 设置或获取节点 data-* 属性
  * @param elem
@@ -155,7 +155,7 @@ export declare function parent(el: HTMLElement): HTMLElement;
  * @param parent - 添加临时节点的父节点, 如果传递 null, 则通过修改原始样式方式计算，默认为: body.
  * @returns The DOMRect of the element.
  */
-export declare function queryHideNodeSize(hideNode: string | HTMLElement, parent?: HTMLElement): {
+export declare function queryHideNodeSize(hideNode: string | HTMLElement, parent?: null | HTMLElement): {
     width: number;
     height: number;
 };

package/lib/dom.js

@@ -78,8 +78,10 @@ export function $$(tag, option = {}, ctx) {
  * @returns 返回匹配的第一个 HTMLElement，如果没有找到则返回 undefined。
  */
 export function $one(selector, dom) {
-    const els = elem(selector, dom);
-    return els.length > 0 ? els[0] : undefined;
+    if (typeof selector === "string") {
+        return (dom || document).querySelector(selector);
+    }
+    return selector;
 }
 /**
  * 为节点添加 class
@@ -294,9 +296,9 @@ export function queryHideNodeSize(hideNode, parent = document.body) {
         const originalVisibility = hideNode.style.visibility;
         const originalPosition = hideNode.style.position;
         // 设置为可见但不可见状态，不影响布局
-        hideNode.style.display = "block";
-        hideNode.style.visibility = "hidden";
         hideNode.style.position = "absolute";
+        hideNode.style.visibility = "hidden";
+        hideNode.style.display = "block";
         // 读取高度
         const rect = hideNode.getBoundingClientRect();
         // 恢复原样式
@@ -317,9 +319,9 @@ export function queryHideNodeSize(hideNode, parent = document.body) {
         $tmpInner.appendChild(hideNode.cloneNode(true));
     }
     $tmp.appendChild($tmpInner);
-    parent.appendChild($tmp);
+    (parent || document.body).appendChild($tmp);
     let rect = $tmpInner.children[0].getBoundingClientRect();
-    parent.removeChild($tmp);
+    (parent || document.body).removeChild($tmp);
     return { width: rect.width, height: rect.height };
 }
 /**

package/lib/id.d.ts

@@ -0,0 +1,66 @@
+/** 雪花ID, 推荐在全局构造一个对象用于生成id */
+export declare class SnowflakeID {
+    /** 机器码, 默认为: 1 */
+    machineId: bigint;
+    /** 起始时间戳, 默认为：1288834974657 */
+    epoch: bigint;
+    _lastTimestamp: bigint;
+    /** 版本号, 默认为: 0 */
+    version: number;
+    private _sequence;
+    /**
+     * 构造函数
+     *
+     * @param machineId 机器标识，默认为1
+     * @param epoch 时间戳起始值，默认为1288834974657
+     */
+    constructor(machineId?: number, epoch?: number);
+    private _getTimestamp;
+    private _waitNextMillis;
+    /**
+     * 生成雪花ID
+     *
+     * @returns 返回生成的唯一ID字符串
+     * @throws 如果时钟回退，抛出错误
+     */
+    generate(): string;
+    parse(snowflakeID: string, epoch?: number, includeVersion?: boolean): {
+        value: string;
+        timeOffset: bigint;
+        timestamp: number;
+        machineId: bigint;
+        sequence: bigint;
+        epoch: number;
+        version: string | undefined;
+    };
+}
+/** 将uuid转换为更简单的唯一标记id */
+export declare class ShortUUID {
+    private alphabet;
+    /**
+     * 构造函数，用于初始化字母表
+     * @param {string} [alphabet] - 可选参数，用于指定自定义字母表
+     * 如果提供了alphabet参数，则将其设置为实例的字母表属性
+     * 如果未提供alphabet参数，则使用默认值
+     */
+    constructor(alphabet?: string);
+    /**
+     * 将UUID字符串进行编码处理
+     * @param uuid - 需要编码的UUID字符串
+     * @returns 编码后的字符串
+     */
+    encode(uuid: string, alphabet?: string): string;
+    /**
+     * 解码短UUID字符串，将其转换为UUID整数和十六进制格式
+     * @param shortUUID - 需要解码的短UUID字符串
+     * @returns 返回包含UUID整数和十六进制格式的对象
+     */
+    decode(shortUUID: string, alphabet?: string): {
+        uuidInt: bigint;
+        uuid: string;
+    };
+    private _stringToInt;
+    private _intToString;
+    private _uuidHexToInt;
+    private _uuidIntToHex;
+}

package/lib/id.js

@@ -0,0 +1,170 @@
+/** 雪花ID, 推荐在全局构造一个对象用于生成id */
+export class SnowflakeID {
+    /**
+     * 构造函数
+     *
+     * @param machineId 机器标识，默认为1
+     * @param epoch 时间戳起始值，默认为1288834974657
+     */
+    constructor(machineId = 1, epoch = 1288834974657) {
+        /** 版本号, 默认为: 0 */
+        this.version = 0;
+        this.machineId = BigInt(machineId);
+        this.epoch = BigInt(epoch);
+        this._lastTimestamp = BigInt(0);
+        this._sequence = BigInt(0);
+    }
+    _getTimestamp() {
+        return BigInt(Date.now());
+    }
+    _waitNextMillis(cTimestamp) {
+        let timestamp = cTimestamp;
+        while (timestamp <= this._lastTimestamp) {
+            timestamp = BigInt(Date.now());
+        }
+        return timestamp;
+    }
+    /**
+     * 生成雪花ID
+     *
+     * @returns 返回生成的唯一ID字符串
+     * @throws 如果时钟回退，抛出错误
+     */
+    generate() {
+        let cTimestamp = this._getTimestamp();
+        if (cTimestamp < this._lastTimestamp) {
+            throw new Error("Clock moved backwards");
+        }
+        if (cTimestamp === this._lastTimestamp) {
+            // TODO: increment sequence
+            // 雪花id，末尾: 12位序列号(二进制12个1等于16进制4095)，最多4096个(从0到4095)
+            this._sequence = (this._sequence + 1n) & BigInt("0xFFF");
+            if (this._sequence === 0n) {
+                // 同一时间戳，序列号溢出，等待下一毫秒
+                cTimestamp = this._waitNextMillis(cTimestamp);
+            }
+        }
+        else {
+            this._sequence = BigInt(0);
+        }
+        this._lastTimestamp = cTimestamp;
+        const timeDiff = cTimestamp - this.epoch;
+        let id = (timeDiff << BigInt(22)) |
+            (this.machineId << BigInt(12)) |
+            this._sequence;
+        let idstr = id.toString().padStart(19, "0");
+        return `${this.version}${idstr}`;
+    }
+    parse(snowflakeID, epoch, includeVersion = true) {
+        let version = undefined;
+        if (includeVersion) {
+            snowflakeID = snowflakeID.substring(1);
+            version = snowflakeID.substring(0, 1);
+        }
+        let epochTime = epoch || Number(this.epoch);
+        const id = BigInt(snowflakeID);
+        // 1FFFFFFFFFF 就是二进制的41个1, 雪花id前面41为为时间戳，间隔部分
+        let timeDiff = (id >> BigInt(22)) & BigInt("0x1FFFFFFFFFF");
+        const flowTime = Number(timeDiff) + epochTime;
+        // 雪花id中间10位为机器标识, 0x3FF(二进制10个1) 进行位运算
+        const machineId = (id >> BigInt(12)) & BigInt("0x3FF");
+        const sequence = id & BigInt("0xFFF");
+        return {
+            value: snowflakeID,
+            timeOffset: timeDiff,
+            timestamp: flowTime,
+            machineId: machineId,
+            sequence: sequence,
+            epoch: epochTime,
+            version,
+        };
+    }
+}
+/** 将uuid转换为更简单的唯一标记id */
+export class ShortUUID {
+    /**
+     * 构造函数，用于初始化字母表
+     * @param {string} [alphabet] - 可选参数，用于指定自定义字母表
+     * 如果提供了alphabet参数，则将其设置为实例的字母表属性
+     * 如果未提供alphabet参数，则使用默认值
+     */
+    constructor(alphabet) {
+        this.alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        if (alphabet) {
+            this.alphabet = alphabet;
+        }
+    }
+    /**
+     * 将UUID字符串进行编码处理
+     * @param uuid - 需要编码的UUID字符串
+     * @returns 编码后的字符串
+     */
+    encode(uuid, alphabet) {
+        // 将UUID字符串转换为整数
+        const uuidInt = this._uuidHexToInt(uuid);
+        // 将整数转换为特定格式的字符串
+        return this._intToString(uuidInt, alphabet);
+    }
+    /**
+     * 解码短UUID字符串，将其转换为UUID整数和十六进制格式
+     * @param shortUUID - 需要解码的短UUID字符串
+     * @returns 返回包含UUID整数和十六进制格式的对象
+     */
+    decode(shortUUID, alphabet) {
+        const uuidInt = this._stringToInt(shortUUID, alphabet);
+        return {
+            uuidInt: uuidInt,
+            uuid: this._uuidIntToHex(uuidInt),
+        };
+    }
+    _stringToInt(str, alphabet) {
+        if (!alphabet)
+            alphabet = this.alphabet;
+        const alphabetlen = BigInt(alphabet.length);
+        let result = BigInt(0);
+        let multiplier = BigInt(1);
+        const strlen = str.length;
+        for (let i = strlen - 1; i >= 0; i--) {
+            const char = str[i];
+            const index = alphabet.indexOf(char);
+            if (index === -1) {
+                throw new Error(`Character "${char}" not found in alphabet`);
+            }
+            result += BigInt(index) * multiplier;
+            multiplier *= alphabetlen;
+        }
+        return result;
+    }
+    _intToString(uuidInt, alphabet) {
+        if (!alphabet)
+            alphabet = this.alphabet;
+        const alphabetlen = BigInt(alphabet.length);
+        let num = uuidInt;
+        const result = [];
+        // uuidInt = d₀ × 1(base的0次方) + d₁ × base + d₂ × base²...
+        while (num) {
+            const index = Number(num % alphabetlen);
+            num = num / alphabetlen;
+            result.push(alphabet.charAt(index));
+        }
+        // 倒序，保证高位在前
+        return result.reverse().join("");
+    }
+    _uuidHexToInt(uuid) {
+        const uuidHex = uuid.replaceAll("-", "");
+        return BigInt(`0x${uuidHex}`);
+    }
+    _uuidIntToHex(uuidInt) {
+        const uuidHexStr = uuidInt.toString(16);
+        if (!/^[0-9a-fA-F]{32}$/.test(uuidHexStr)) {
+            throw new Error("Invalid UUID string (must be 32 hex characters)");
+        }
+        return [
+            uuidHexStr.slice(0, 8),
+            uuidHexStr.slice(8, 12),
+            uuidHexStr.slice(12, 16),
+            uuidHexStr.slice(16, 20),
+            uuidHexStr.slice(20),
+        ].join("-");
+    }
+}

package/lib/validator.js

@@ -13,7 +13,7 @@ const ruleRegexs = {
     /** 验证跟其余数据相等的正则，一般用于验证再次输入密码 */
     same: /^same:(.+)$/i,
     /** 验证手机号的正则表达式 */
-    mobile: /^1[345678]\d{9}$/,
+    mobile: /^1[3456789]\d{9}$/,
     /** 非空验证的正则表达式 */
     required: /^\S{1}.*/,
 };
@@ -128,6 +128,8 @@ class Validator {
     _validateRule(rules, value, data) {
         let errMsg = "";
         for (let rule of rules) {
+            if (!rule)
+                continue;
             // 如果数据为空，则判断是否是必填
             if (rule.rule === "required") {
                 if (value == null || !ruleFns.pattern(ruleRegexs.required, value)) {
@@ -147,7 +149,7 @@ class Validator {
                 }
             }
             else {
-                if (!ruleFns.pattern(rule.rule, value)) {
+                if (rule && !ruleFns.pattern(rule.rule, value)) {
                     errMsg = rule.message;
                 }
             }
@@ -166,7 +168,7 @@ class Validator {
         }
         if (rule != null) {
             if (typeof rule === "string") {
-                rules = rules.concat(this._parseStringRule(rule, schema.message));
+                rules.push(...this._parseStringRule(rule, schema.message));
             }
             else if (rule instanceof Array) {
                 for (let ruleItem of rule) {
@@ -181,13 +183,14 @@ class Validator {
                         });
                     }
                     else {
+                        const emessage = ruleItem.message || schema.message || defaultMsg;
                         if (typeof ruleItem.rule === "string") {
-                            rules.push(...this._parseStringRule(ruleItem.rule, ruleItem.message));
+                            rules.push(...this._parseStringRule(ruleItem.rule, emessage));
                         }
                         else {
                             rules.push({
                                 rule: ruleItem.rule,
-                                message: ruleItem.message || defaultMsg,
+                                message: emessage,
                             });
                         }
                     }
@@ -225,7 +228,9 @@ class Validator {
                 rrule = ruleRegexs[r];
                 message = message || defaultMsgs[r];
             }
-            rules.push({ rule: rrule, message: message, sameKey });
+            if (rrule) {
+                rules.push({ rule: rrule, message: message, sameKey });
+            }
         }
         return rules;
     }

package/package.json

@@ -68,7 +68,7 @@
     },
     "./*": "./lib/*"
   },
-  "version": "0.15.4",
+  "version": "0.16.0",
   "type": "module",
   "repository": {
     "type": "git",