ph-utils 0.15.5 → 0.16.1

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

@@ -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

package/lib/dom.js

@@ -296,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();
         // 恢复原样式

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/web.d.ts

@@ -24,4 +24,7 @@ export declare function throttle<R extends any[], T>(fn: (...args: R) => T, wait
  * @param interval  间隔时间段
  * @returns
  */
-export declare function debounce<R extends any[], T>(fn: (...args: R) => T, interval?: number): (...args: R) => void;
+export declare function debounce<R extends any[], T>(fn: (...args: R) => T, interval?: number): {
+    (...args: R): void;
+    cancel(): void;
+};

package/lib/web.js

@@ -1,7 +1,7 @@
 /**
  * web(浏览器) 端工具类
  */
-import { isBlank } from './index.js';
+import { isBlank } from "./index.js";
 /**
  * 解析 Form 表单中的 input 元素的数据为 JSON 格式，key: input-name；value: input-value
  * @param form {object} Form 节点对象
@@ -12,16 +12,17 @@ export const formJson = function (form) {
     for (let i = 0, len = elems.length; i < len; i++) {
         let item = elems[i];
         if (!isBlank(item.name)) {
-            if ((item.tagName === 'INPUT' || item.tagName === 'TEXTAREA') && !isBlank(item.value)) {
-                let dataType = item.getAttribute('data-type');
-                if (dataType === 'number') {
+            if ((item.tagName === "INPUT" || item.tagName === "TEXTAREA") &&
+                !isBlank(item.value)) {
+                let dataType = item.getAttribute("data-type");
+                if (dataType === "number") {
                     value[item.name] = Number(item.value);
                 }
                 else {
                     value[item.name] = item.value;
                 }
             }
-            else if (item.tagName === 'SELECT') {
+            else if (item.tagName === "SELECT") {
                 value[item.name] = item.options[item.selectedIndex].value;
             }
         }
@@ -80,11 +81,19 @@ export function throttle(fn, wait = 500) {
  * @returns
  */
 export function debounce(fn, interval = 500) {
-    let _t = -1;
-    return (...args) => {
-        clearTimeout(_t);
+    let _t;
+    const handle = (...args) => {
+        if (_t)
+            clearTimeout(_t);
         _t = setTimeout(() => {
             fn(...args);
         }, interval);
     };
+    handle.cancel = function () {
+        if (_t) {
+            clearTimeout(_t);
+            _t = null;
+        }
+    };
+    return handle;
 }

package/package.json

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