ph-utils 0.20.0 → 1.0.0

package/lib/file.js

@@ -1,54 +0,0 @@
-/** nodejs 文件操作工具类 */
-import path from "node:path";
-import fs from "node:fs/promises";
-/**
- * 读取文件内容
- * @example <caption>1. 读取JSON文件, 内容为字符串列表</caption>
- * read<string[]>('a.json', []);
- * @example <caption>2. 读取JSON文件, 内容为对象</caption>
- * read<{ name: string }>('b.json', {});
- * @param filepath     文件路径
- * @param defaultValue 文件不存在时默认值, 不传则抛异常, 如果传递的是对象形式则会将结果转换为 JSON
- * @returns 文件内容
- */
-export async function read(filepath, defaultValue) {
-    let content;
-    try {
-        content = await fs.readFile(filepath, "utf8");
-        if (defaultValue != null && typeof defaultValue === "object") {
-            return JSON.parse(content);
-        }
-        return content;
-    }
-    catch (error) {
-        if (defaultValue === undefined) {
-            throw error;
-        }
-        return defaultValue;
-    }
-}
-/**
- * 写入 JSON 格式的数据到文件
- * @param file 待写入的文件
- * @param data 待写入的数据
- * @param opts 写入配置
- * @property opts.json 是否写入 JSON 格式的数据，写入数据时对数据进行 JSON 格式化，默认为：true
- * @property opts.format 是否在写入 json 数据时，将 JSON 数据格式化2个空格写入, 默认为 true
- */
-export async function write(file, data, opts) {
-    let writeData = data.toString();
-    opts = { json: true, format: true, ...opts };
-    if (opts.json === true && typeof data === "object") {
-        writeData = JSON.stringify(data, null, opts.format === true ? 2 : 0);
-    }
-    await fs.writeFile(path.resolve(file), writeData);
-}
-/**
- * 根据文件的 stat 获取文件的 etag
- * @param filePath 文件地址
- * @returns file stat etag
- */
-export async function statTag(filePath) {
-    let stat = await fs.stat(filePath);
-    return `${stat.size.toString(16)}-${stat.mtimeMs.toString(16)}`;
-}

package/lib/id.d.ts

@@ -1,68 +0,0 @@
-type SnowflakeIDInfo = {
-    value: string;
-    timeOffset: bigint;
-    timestamp: number;
-    machineId: bigint;
-    sequence: bigint;
-    epoch: number;
-    version: string | undefined;
-};
-/** 雪花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): SnowflakeIDInfo;
-}
-/** 将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;
-}
-export {};

package/lib/id.js

@@ -1,170 +0,0 @@
-/** 雪花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: 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/logger.d.ts

@@ -1,62 +0,0 @@
-type LoggerLevel = "debug" | "info" | "warn" | "error" | "fatal";
-/** 日志消息类型 */
-type MessageIntf = number | string | boolean | object | any[] | Error;
-/** 日志消息选项 */
-type MessageOption = {
-    /** 日志名称 */
-    name?: string;
-    /** 日志级别 */
-    level?: LoggerLevel;
-    /** 日志消息 */
-    message: MessageIntf;
-    /** 当前消息是否美化输出 */
-    pretty?: boolean;
-    /** 如果消息是 JSON 格式, 转换为字符串时, 是否格式化 JSON */
-    jsonSpace?: number;
-};
-type LoggerOption = {
-    /** 记录的日志名称, 通常用于表明哪个页面 */
-    name?: string;
-    /** 记录日志级别, 通常上线时 error 或者禁用日志, 默认: debug */
-    level?: LoggerLevel;
-    /** 是否需要美化输出, 默认: true */
-    pretty?: boolean;
-};
-/**
- * 日志记录器
- */
-export declare class Logger {
-    /** 日志级别 */
-    levels: string[];
-    colors: {
-        debug: string;
-        info: string;
-        warn: string;
-        error: string;
-    };
-    option: LoggerOption & {
-        levelNum: number;
-    };
-    /** 构造日志记录器 */
-    constructor(option?: LoggerOption);
-    setOption(option: LoggerOption): void;
-    log(message: MessageIntf | MessageOption): void;
-    info(message: MessageIntf | MessageOption): void;
-    debug(message: MessageIntf | MessageOption): void;
-    warn(message: MessageIntf | MessageOption): void;
-    error(message: MessageIntf | MessageOption): void;
-    fatal(message: MessageIntf | MessageOption): void;
-    getLevel(): string;
-    getName(): string | undefined;
-    getOption(): LoggerOption & {
-        levelNum: number;
-    };
-    private generateLog;
-    /** 格式化显示 */
-    private formatShow;
-}
-/** 默认日志记录器 */
-export declare const logger: Logger;
-/** 获取新的日志记录器, 属性采用之前的 */
-export declare const getLogger: (option?: LoggerOption) => Logger;
-export {};

package/lib/logger.js

@@ -1,122 +0,0 @@
-import { format } from "./date.js";
-/**
- * 日志记录器
- */
-export class Logger {
-    /** 构造日志记录器 */
-    constructor(option) {
-        /** 日志级别 */
-        this.levels = ["debug", "info", "warn", "error", "fatal"];
-        this.colors = {
-            debug: "#909399",
-            info: "#1677ff",
-            warn: "#fadb14",
-            error: "#eb2f96",
-        };
-        this.setOption(option || {});
-    }
-    setOption(option) {
-        let opts = { level: "debug", levelNum: 0, pretty: true, ...option };
-        opts.levelNum = this.levels.indexOf(opts.level);
-        this.option = opts;
-    }
-    log(message) {
-        let msgInfo = {
-            name: this.option.name,
-            level: "info",
-            time: format(null, "yyyy-mm-dd HH:MM:ss.S"),
-            pretty: this.option.pretty,
-            jsonSpace: 0,
-        };
-        let msgContent = message;
-        if (typeof message === "object") {
-            if (message instanceof Error) {
-                msgInfo.level = "error";
-                msgContent = msgContent.stack;
-            }
-            else if (message.message != null) {
-                msgContent = message.message;
-                msgInfo = { ...msgInfo, ...message };
-            }
-        }
-        if (typeof msgContent === "object") {
-            try {
-                msgInfo.message = JSON.stringify(msgContent, null, msgInfo.jsonSpace);
-            }
-            catch (error) {
-                msgInfo.message = msgContent.toString();
-            }
-        }
-        else {
-            msgInfo.message = msgContent;
-        }
-        if (msgInfo.pretty == null) {
-            msgInfo.pretty = this.option.pretty;
-        }
-        let levelIndex = this.levels.indexOf(msgInfo.level);
-        if (levelIndex >= this.option.levelNum) {
-            this.formatShow(msgInfo);
-        }
-    }
-    info(message) {
-        this.log(this.generateLog(message, "info"));
-    }
-    debug(message) {
-        this.log(this.generateLog(message, "debug"));
-    }
-    warn(message) {
-        this.log(this.generateLog(message, "warn"));
-    }
-    error(message) {
-        this.log(this.generateLog(message, "error"));
-    }
-    fatal(message) {
-        this.log(this.generateLog(message, "fatal"));
-    }
-    getLevel() {
-        return this.levels[this.option.levelNum];
-    }
-    getName() {
-        return this.option.name;
-    }
-    getOption() {
-        return this.option;
-    }
-    generateLog(message, level = "info") {
-        let msgInfo = {
-            message: message,
-        };
-        if (typeof message === "object") {
-            if (message.message != null) {
-                msgInfo = message;
-            }
-        }
-        msgInfo["level"] = level;
-        return msgInfo;
-    }
-    /** 格式化显示 */
-    formatShow(msg) {
-        if (msg.level === "fatal") {
-            msg.level = "error";
-        }
-        const res = [`[${msg.time}]`];
-        if (msg.name != null) {
-            res.push(`[${msg.name}]`);
-        }
-        res.push(`- ${msg.message}`);
-        if (!msg.pretty) {
-            res.splice(1, 0, `${msg.level.toUpperCase()}`);
-            console[msg.level](res.join(" "));
-        }
-        else {
-            const color = this.colors[msg.level];
-            console.log(`%c ${`${msg.level.toUpperCase()}`} %c ${res.join(" ")} %c`, `background:${color};border:1px solid ${color}; padding: 1px; border-radius: 2px 0 0 2px; color: #fff;`, `border:1px solid ${color}; padding: 1px; border-radius: 0 2px 2px 0; color: ${color};`, "background:transparent");
-        }
-    }
-}
-/** 默认日志记录器 */
-export const logger = new Logger({ name: "APP" });
-/** 获取新的日志记录器, 属性采用之前的 */
-export const getLogger = (option) => {
-    return new Logger({ ...logger.getOption(), ...option });
-};

package/lib/server.d.ts

@@ -1,33 +0,0 @@
-import type { SpawnOptionsWithoutStdio } from "node:child_process";
-/**
- * 执行命令
- * @param command 待执行的命令
- * @param args    命令参数
- */
-export declare function exec(command: string, args?: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-export declare function exec(command: string, options?: SpawnOptions): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-export declare function exec(command: string, args?: string[], options?: SpawnOptions): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-type SpawnOptions = SpawnOptionsWithoutStdio & {
-    shell?: 'powershell';
-};
-/**
- * 执行命令并返回执行结果的Promise
- * @param command 要执行的命令
- * @param args 命令参数数组
- * @param options 执行选项，支持指定shell类型
- * @returns Promise对象，成功时resolve包含stdout和stderr的对象，失败时reject包含错误信息
- */
-export declare function spawn(command: string, args?: string[], options?: SpawnOptions): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-export {};

package/lib/server.js

@@ -1,65 +0,0 @@
-import { execFile, spawn as spawnOri } from "node:child_process";
-import { promisify } from "node:util";
-const execFilePromise = promisify(execFile);
-/**
- * 执行命令
- * @param cmd 执行的命令
- * @returns
- */
-export function exec(command, ...params) {
-    let argvs = [];
-    const commandItems = command.split(" ");
-    const cmd = commandItems.shift();
-    if (commandItems.length > 0) {
-        argvs = commandItems;
-    }
-    let opts = { shell: true };
-    if (params[0] != null) {
-        if (params[0] instanceof Array) {
-            argvs.push(...params[0]);
-            if (params[1] != null) {
-                opts = params[1];
-            }
-        }
-        else {
-            opts = params[0];
-        }
-    }
-    return execFilePromise(cmd, argvs, opts);
-}
-/**
- * 执行命令并返回执行结果的Promise
- * @param command 要执行的命令
- * @param args 命令参数数组
- * @param options 执行选项，支持指定shell类型
- * @returns Promise对象，成功时resolve包含stdout和stderr的对象，失败时reject包含错误信息
- */
-export function spawn(command, args, options = {}) {
-    return new Promise((resolve, reject) => {
-        let execArgs = [];
-        let cmd;
-        // 根据是否指定powershell shell来设置实际执行的命令和参数
-        if (options.shell === 'powershell') {
-            cmd = 'powershell.exe';
-            execArgs = ['-NoProfile', '-Command', command, ...(args || [])];
-        }
-        else {
-            cmd = command;
-            execArgs = args || [];
-        }
-        delete options.shell;
-        const child = spawnOri(cmd, execArgs, options);
-        let stdout = '', stderr = '';
-        child.stdout.on('data', d => stdout += d);
-        child.stderr.on('data', d => stderr += d);
-        // 监听子进程关闭事件，根据退出码决定resolve或reject
-        child.on('close', code => {
-            if (code === 0)
-                resolve({ stdout, stderr });
-            else
-                reject(new Error(`spawn failed (${code}): ${stderr}`));
-        });
-        // 监听子进程错误事件，发生错误时直接reject
-        child.on('error', reject);
-    });
-}

package/lib/storage.d.ts

@@ -1,51 +0,0 @@
-/**
- * 缓存相关
- */
-type StorageType = "session" | "local";
-interface StorageSetOption {
-    storage?: StorageType;
-    /** 数据有效期, 单位秒, 默认: -1 - 永久存储 */
-    expire?: number;
-}
-/**
- * 存储值到 Storage 中
- * @param key 设置的 key
- * @param value 设置的值
- * @param [option.storage] session 或 local, 默认: session
- * @param [option.expire] 数据有效期, 单位秒, 默认: -1 - 永久存储
- *
- * @example <caption>1. 存储到 SessionStorage</caption>
- * set("key", "value");
- *
- * @example <caption>2. 存储到 LocalStorage</caption>
- * set("key", "value", { storage: "local" });
- */
-export declare function set(key: string, value: any, option?: StorageSetOption): void;
-/**
- * 清空所有的缓存内容
- * @param storage 待清空的缓存对象
- */
-export declare function clear(storage?: StorageType): void;
-/**
- * 删除存储到 Storage 中的数据
- * @param key
- * @param storage
- */
-export declare function remove(key: string, storage?: StorageType): void;
-/** 从 Storage 中获取数据时的配置 */
-interface StorageQueryOption {
-    /** 数据是否持久化, 默认为: false, 设置为 true 则会在每一次取出数据后删除 */
-    delete?: boolean;
-    /** 存储对象, session、local */
-    storage?: StorageType;
-}
-/**
- * 从 Storage 中取出数据
- * @param key 保存时的 key
- * @param defaultValue 没有数据时的默认值
- * @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;
-export {};