ph-utils 0.20.0 → 0.20.1

package/lib/src/config.d.ts

@@ -0,0 +1,33 @@
+/** 配置信息 */
+export declare let config: Record<string, any>;
+/**
+ * 解析环境变量;
+ * 同时读取多个环境变量文件: .env, .env.local, .env.[development|test|production];
+ * 根据运行环境变量 `NODE_ENV` 读取不同的环境变量文件;
+ * 同时支持手动通过运行命令指定 `NODE_ENV` 值, 不指定默认为: production
+ *
+ * ```bash
+ * node test.js --NODE_ENV development
+ * // or
+ * node test.js -n development
+ * ```
+ *
+ * ```js
+ * // test.js
+ * parseEnvs();
+ * ```
+ *
+ * @returns
+ */
+export declare function parseEnv(envFiles?: string[]): Record<string, string>;
+/**
+ * 解析配置文件并合并内容。
+ *
+ * @param files - 要解析的配置文件列表，默认为 ["config.json", "config.local.json"]。
+ * @param runParseEnv - 是否运行环境变量解析，默认为 true。
+ * @returns 合并后的配置对象。
+ *
+ * 该函数会根据当前环境加载相应的配置文件，并将其内容合并到最终的配置对象中。
+ * 如果指定的文件列表中不包含环境特定的配置文件，则会自动添加。
+ */
+export declare function parseConfig(files?: string[], runParseEnv?: boolean): Record<string, any>;

package/lib/src/config.js

@@ -0,0 +1,99 @@
+import { parseEnv as readEnv, parseArgs } from "node:util";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** 配置信息 */
+export let config = {};
+/**
+ * 解析环境变量;
+ * 同时读取多个环境变量文件: .env, .env.local, .env.[development|test|production];
+ * 根据运行环境变量 `NODE_ENV` 读取不同的环境变量文件;
+ * 同时支持手动通过运行命令指定 `NODE_ENV` 值, 不指定默认为: production
+ *
+ * ```bash
+ * node test.js --NODE_ENV development
+ * // or
+ * node test.js -n development
+ * ```
+ *
+ * ```js
+ * // test.js
+ * parseEnvs();
+ * ```
+ *
+ * @returns
+ */
+export function parseEnv(envFiles = [".env", ".env.local"]) {
+    // development, test, production
+    const files = [...envFiles];
+    let nodeEnv = process.env.NODE_ENV;
+    const { values } = parseArgs({
+        options: {
+            NODE_ENV: {
+                type: "string",
+                short: "n",
+            },
+        },
+        strict: false,
+    });
+    if (values.NODE_ENV != null && typeof values.NODE_ENV === "string") {
+        nodeEnv = values.NODE_ENV;
+    }
+    if (nodeEnv == null) {
+        nodeEnv = "production";
+    }
+    process.env.NODE_ENV = nodeEnv;
+    const envFile = `.env.${nodeEnv}`;
+    if (!files.includes(envFile)) {
+        files.push(envFile);
+    }
+    let envParsed = {};
+    for (let i = 0, len = files.length; i < len; i++) {
+        const file = join(process.cwd(), files[i]);
+        try {
+            const envContent = readFileSync(file, {
+                encoding: "utf-8",
+            });
+            const envValue = readEnv(envContent);
+            for (const key in envValue) {
+                process.env[key] = envValue[key];
+                envParsed[key] = envValue[key];
+            }
+            // eslint-disable-next-line
+        }
+        catch (err) { }
+    }
+    return envParsed;
+}
+/**
+ * 解析配置文件并合并内容。
+ *
+ * @param files - 要解析的配置文件列表，默认为 ["config.json", "config.local.json"]。
+ * @param runParseEnv - 是否运行环境变量解析，默认为 true。
+ * @returns 合并后的配置对象。
+ *
+ * 该函数会根据当前环境加载相应的配置文件，并将其内容合并到最终的配置对象中。
+ * 如果指定的文件列表中不包含环境特定的配置文件，则会自动添加。
+ */
+export function parseConfig(files, runParseEnv = true) {
+    let d = [...(files || ["config.json", "config.local.json"])];
+    if (runParseEnv) {
+        parseEnv();
+    }
+    const envConfigPath = `config.${process.env.NODE_ENV}.json`;
+    if (!d.includes(envConfigPath)) {
+        d.push(envConfigPath);
+    }
+    for (let i = 0, len = d.length; i < len; i++) {
+        const filePath = join(process.cwd(), d[i]);
+        try {
+            const content = readFileSync(filePath, {
+                encoding: "utf-8",
+            });
+            let contentJson = JSON.parse(content);
+            config = { ...config, ...contentJson };
+            // eslint-disable-next-line
+        }
+        catch (err) { }
+    }
+    return config;
+}

package/lib/src/copy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 复制数据, 可以从多种类型的数据
+ *    1. 直接复制文本: await copy("待复制的文本")
+ *    2. 复制节点上的 data-copy-text:
+ *      <button data-copy-text="这是待复制的文本">复制</button>
+ *      await copy(e.target) // or await copy("#a") or await copy(document.querySelector('#a'))
+ *    3. 直接复制节点本身数据: await copy('#a')
+ * @param {string | HTMLElement} source 复制源, 从中解析待复制的数据
+ * @returns {Promise<boolean>} 是否复制成功
+ */
+export declare function copy(source: string | HTMLElement): Promise<boolean>;

package/lib/src/copy.js

@@ -0,0 +1,101 @@
+/**
+ * 创建一个临时节点缓存待复制数据
+ * @param {String} value
+ * @return {HTMLElement}
+ */
+function createFakeElement(value) {
+    const fakeElement = document.createElement("textarea");
+    fakeElement.style.border = "0";
+    fakeElement.style.padding = "0";
+    fakeElement.style.margin = "0";
+    fakeElement.style.position = "absolute";
+    fakeElement.style.left = "-9999px";
+    fakeElement.style.top = "-9999";
+    fakeElement.setAttribute("readonly", "");
+    fakeElement.value = value;
+    return fakeElement;
+}
+/** 通过执行 execCommand 来执行复制 */
+function copyFromCommand(text) {
+    // 添加节点
+    const fakeEl = createFakeElement(text);
+    document.body.append(fakeEl);
+    fakeEl.focus();
+    fakeEl.select();
+    // 执行复制
+    const res = document.execCommand("copy");
+    fakeEl.remove(); // 删除节点
+    return Promise.resolve(res);
+}
+/** 使用 navigator.clipboard 复制 */
+function copyFromClipboard(text) {
+    const theClipboard = navigator.clipboard;
+    if (theClipboard != null) {
+        return theClipboard
+            .writeText(text)
+            .then(() => {
+            Promise.resolve(true);
+        })
+            .catch(() => Promise.resolve(false));
+    }
+    return Promise.resolve(false);
+}
+/** 解析待复制的文本 */
+function parseCopyText(source) {
+    let copyText = null; // 待复制文本
+    let sourceEl = null;
+    // 获取待复制数据
+    if (typeof source === "string") {
+        // 从节点拿数据
+        if (source.startsWith("#") || source.startsWith(".")) {
+            sourceEl = document.querySelector(source);
+            if (sourceEl == null) {
+                copyText = source;
+            }
+        }
+        else {
+            copyText = source;
+        }
+    }
+    if (source instanceof HTMLElement) {
+        sourceEl = source;
+    }
+    // 从节点获取待复制数据
+    if (sourceEl != null) {
+        if (sourceEl.hasAttribute("data-copy-text")) {
+            copyText = sourceEl.getAttribute("data-copy-text");
+        }
+        else {
+            const tagName = sourceEl.tagName;
+            if (tagName === "INPUT" || tagName === "TEXTAREA") {
+                copyText = sourceEl.value;
+            }
+            else {
+                copyText = sourceEl.textContent;
+            }
+        }
+    }
+    return copyText;
+}
+/**
+ * 复制数据, 可以从多种类型的数据
+ *    1. 直接复制文本: await copy("待复制的文本")
+ *    2. 复制节点上的 data-copy-text:
+ *      <button data-copy-text="这是待复制的文本">复制</button>
+ *      await copy(e.target) // or await copy("#a") or await copy(document.querySelector('#a'))
+ *    3. 直接复制节点本身数据: await copy('#a')
+ * @param {string | HTMLElement} source 复制源, 从中解析待复制的数据
+ * @returns {Promise<boolean>} 是否复制成功
+ */
+export async function copy(source) {
+    // 待复制文本
+    const copyText = parseCopyText(source);
+    if (copyText == null) {
+        return Promise.resolve(false);
+    }
+    const v = await copyFromClipboard(copyText);
+    if (v === false) {
+        return copyFromCommand(copyText);
+    }
+    return Promise.resolve(true);
+}

package/lib/src/crypto.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 将原始的二进制数据转换为 Hex String
+ * @param bf 待转换的原始数据
+ * @param upper 是否需要转换为大写
+ * @returns
+ */
+export declare function bufferToHex(bf: ArrayBuffer | Uint8Array, upper?: boolean): string;
+/**
+ * SHA 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export declare function sha(message: string | ArrayBuffer, upper?: boolean, algorithm?: string): Promise<string>;
+/**
+ * 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export declare function hash(message: string | ArrayBuffer, upper?: boolean, algorithm?: string): Promise<string>;
+type HMACAlgorithm = "SHA-256" | "SHA-512";
+/**
+ * 使用 HMAC 算法计算消息的哈希值
+ * @param message - 需要计算哈希的消息字符串
+ * @param secret - 用于生成 HMAC 的密钥
+ * @param algorithm - HMAC 使用的哈希算法,默认为 "SHA-256"
+ * @param upper - 是否将结果转换为大写,默认为 false
+ * @returns 返回十六进制格式的 HMAC 哈希值
+ */
+export declare function hmacHash(message: string, secret: string, algorithm?: HMACAlgorithm, upper?: boolean): Promise<string>;
+/** 返回结果类似 */
+type AlgorithmResType = "hex" | "hexUpper" | "base64" | "raw";
+/**
+ * AES 加密
+ * @param message 待加密的数据
+ * @param key 加解密密钥
+ * @param encode 加密后的数据转换的形式, hex - 转换为16进制字符串, hexUpper - 转换为16进制且大写, base64 - 转换为 base64 形式
+ * @param iv 加解密向量
+ * @returns [加密数据,向量]
+ */
+export declare function aesEncrypt(message: string, key: string, encode?: AlgorithmResType, iv?: null | Uint8Array | string): Promise<{
+    ciphertext: string | ArrayBuffer;
+    iv: string;
+    key: string;
+}>;
+/**
+ * AES 解密
+ * @param message 加密后的数据
+ * @param key     解密密钥
+ * @param iv      向量
+ * @param encode  加密后数据的形式: hex | base64
+ * @returns
+ */
+export declare function aesDecrypt(message: Uint8Array | string, key: string, iv: string, encode?: AlgorithmResType): Promise<string>;
+/**
+ * RSA 加密
+ * @param key     公钥
+ * @param message 待加密数据
+ * @param encode  返回类型
+ * @returns
+ */
+export declare function rsaEncrypt(message: string, publicKey: string, encode?: AlgorithmResType): Promise<string | ArrayBuffer>;
+/**
+ * RSA 解密
+ * @param key     私钥, 根据私钥解密
+ * @param message 加密后的数据
+ * @param encode  加密后的数据形式
+ * @returns
+ */
+export declare function rsaDecrypt(privateKey: string, message: Uint8Array | string, encode?: AlgorithmResType): Promise<string>;
+export {};

package/lib/src/crypto.js

@@ -0,0 +1,261 @@
+/* eslint-disable no-undef */
+/**
+ * 将原始的二进制数据转换为 Hex String
+ * @param bf 待转换的原始数据
+ * @param upper 是否需要转换为大写
+ * @returns
+ */
+export function bufferToHex(bf, upper = false) {
+    const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+    const hashArray = Array.from(u8Array);
+    return hashArray
+        .map((b) => {
+        let hx = b.toString(16).padStart(2, "0");
+        return upper === true ? hx.toUpperCase() : hx;
+    })
+        .join("");
+}
+/**
+ * 将16进制的数据转换为 UInt8Array
+ * @param data 16进制的数据
+ * @returns
+ */
+function hexToBuffer(data) {
+    const len = data.length / 2;
+    const uint8Array = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        const byteHex = data.substring(i * 2, i * 2 + 2);
+        const byte = parseInt(byteHex.toLocaleLowerCase(), 16);
+        uint8Array[i] = byte;
+    }
+    return uint8Array;
+}
+/**
+ * 将原始数据转换为 Base64 编码
+ * @param bf 待转换的原始数据
+ * @returns
+ */
+function bufferToBase64(bf) {
+    const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
+    const hashArray = Array.from(u8Array);
+    return globalThis.btoa(String.fromCharCode.apply(null, hashArray));
+}
+/**
+ * 将 Base64 转换为 UInt8Array 数据
+ * @param data
+ * @returns
+ */
+function base64ToBuffer(data) {
+    return new Uint8Array(globalThis
+        .atob(data)
+        .split("")
+        .map((char) => char.charCodeAt(0)));
+}
+/**
+ * SHA 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export async function sha(message, upper = false, algorithm = "SHA-256") {
+    let msgBuffer = message;
+    if (typeof message === "string") {
+        msgBuffer = new TextEncoder().encode(message);
+    }
+    const hashBuffer = await globalThis.crypto.subtle.digest(algorithm || "SHA-256", msgBuffer);
+    return bufferToHex(hashBuffer, upper);
+}
+/**
+ * 哈希算法
+ * @param message     待进行 hash 的数据
+ * @param upper       是否转换为大写, 默认为: false
+ * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
+ * @returns
+ */
+export async function hash(message, upper = false, algorithm = "SHA-256") {
+    return sha(message, upper, algorithm);
+}
+/**
+ * 使用 HMAC 算法计算消息的哈希值
+ * @param message - 需要计算哈希的消息字符串
+ * @param secret - 用于生成 HMAC 的密钥
+ * @param algorithm - HMAC 使用的哈希算法,默认为 "SHA-256"
+ * @param upper - 是否将结果转换为大写,默认为 false
+ * @returns 返回十六进制格式的 HMAC 哈希值
+ */
+export async function hmacHash(message, secret, algorithm = "SHA-256", upper = false) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: { name: algorithm } }, false, ["sign"]);
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+    return bufferToHex(signature, upper);
+}
+function parseRsaKey(pem) {
+    const pemHeader = "-----BEGIN PUBLIC KEY-----";
+    const pemFooter = "-----END PUBLIC KEY-----";
+    if (pem.indexOf(pemHeader) !== -1 && pem.indexOf(pemFooter) !== -1) {
+        pem = pem.substring(pemHeader.length, pem.indexOf(pemFooter)).trim();
+    }
+    return pem;
+}
+/**
+ * 导入上下文密钥
+ * @param key           导入的密钥
+ * @param algorithmName 算法名称
+ * @param usages        该密钥可以用于哪些函数使用
+ * @returns
+ */
+// eslint-disable-next-line no-undef
+async function importKey(key, algorithmName, usages, encoding = "hex") {
+    let name = "AES-CBC";
+    if (algorithmName == null) {
+        name = "AES-CBC";
+    }
+    else {
+        if (algorithmName.toUpperCase() === "AES") {
+            name = "AES-CBC";
+        }
+        else if (algorithmName.toUpperCase() === "RSA") {
+            name = "RSA-OAEP";
+        }
+    }
+    name = name.toUpperCase();
+    if (usages == null || usages.length === 0) {
+        usages = ["encrypt"];
+    }
+    let format = "raw";
+    let algorithm = { name };
+    if (name.includes("RSA")) {
+        format = "spki";
+        algorithm.hash = { name: "SHA-256" };
+        key = parseRsaKey(key);
+    }
+    const keyBuf = encoding === "base64" ? base64ToBuffer(key) : hexToBuffer(key);
+    // importKey时传 false 表明该密钥不能被导出
+    return Promise.all([
+        globalThis.crypto.subtle.importKey(format, keyBuf, algorithm, false, usages),
+        Promise.resolve({ name }),
+    ]);
+}
+/**
+ * 加密
+ * @param algorithm  算法参数, 算法名称、向量等
+ * @param key        算法密钥
+ * @param message    待加密的数据
+ * @param encode     解密后返回数据格式
+ * @returns
+ */
+async function encrypt(algorithm, key, message, encode = "hex") {
+    if (typeof message === "string") {
+        message = new TextEncoder().encode(message);
+    }
+    const encrypted = await globalThis.crypto.subtle.encrypt(algorithm, key, message);
+    if (encode === "hex") {
+        return bufferToHex(encrypted);
+    }
+    else if (encode === "hexUpper") {
+        return bufferToHex(encrypted, true);
+    }
+    else if (encode === "base64") {
+        return bufferToBase64(encrypted);
+    }
+    else {
+        return encrypted;
+    }
+}
+/**
+ * 数据解密
+ * @param algorithm 解密算法
+ * @param key       解密密钥
+ * @param message   加密后的数据
+ * @returns
+ */
+async function decrypt(algorithm, key, message) {
+    const decrypted = await globalThis.crypto.subtle.decrypt(algorithm, key, message);
+    return new TextDecoder("utf-8").decode(decrypted);
+}
+/**
+ * AES 加密
+ * @param message 待加密的数据
+ * @param key 加解密密钥
+ * @param encode 加密后的数据转换的形式, hex - 转换为16进制字符串, hexUpper - 转换为16进制且大写, base64 - 转换为 base64 形式
+ * @param iv 加解密向量
+ * @returns [加密数据,向量]
+ */
+export async function aesEncrypt(message, key, encode = "hex", iv = null) {
+    let ciphertext = "";
+    let resIv = "";
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["encrypt"]);
+    if (iv == null) {
+        iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
+    }
+    else if (typeof iv === "string") {
+        iv = hexToBuffer(iv);
+    }
+    const encodeData = await encrypt({ ...algorithm, iv: iv }, cryptoKey, message, encode);
+    ciphertext = encodeData;
+    resIv = bufferToHex(iv);
+    return { ciphertext, iv: resIv, key };
+}
+/**
+ * 根据加密后的数据类型使用对应函数最终转换为 UInt8Array
+ * @param message 原始加密后的数据
+ * @param type    类型: hex | base64
+ * @returns
+ */
+function parseEncryptData(message, type) {
+    let input;
+    if (typeof message === "string") {
+        if (type === "hex" || type === "hexUpper") {
+            input = hexToBuffer(message);
+        }
+        else {
+            input = base64ToBuffer(message);
+        }
+    }
+    else {
+        input = message;
+    }
+    return input;
+}
+/**
+ * AES 解密
+ * @param message 加密后的数据
+ * @param key     解密密钥
+ * @param iv      向量
+ * @param encode  加密后数据的形式: hex | base64
+ * @returns
+ */
+export async function aesDecrypt(message, key, iv, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["decrypt"]);
+    const input = parseEncryptData(message, encode);
+    return await decrypt({ ...algorithm, iv: hexToBuffer(iv) }, cryptoKey, input);
+}
+/**
+ * RSA 加密
+ * @param key     公钥
+ * @param message 待加密数据
+ * @param encode  返回类型
+ * @returns
+ */
+export async function rsaEncrypt(message, publicKey, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(publicKey, "rsa", ["encrypt"], "base64");
+    return await encrypt(algorithm, cryptoKey, message, encode);
+}
+/**
+ * RSA 解密
+ * @param key     私钥, 根据私钥解密
+ * @param message 加密后的数据
+ * @param encode  加密后的数据形式
+ * @returns
+ */
+export async function rsaDecrypt(privateKey, message, encode = "hex") {
+    // 导入密钥
+    const [cryptoKey, algorithm] = await importKey(privateKey, "rsa", [
+        "decrypt",
+    ]);
+    return await decrypt({ ...algorithm }, cryptoKey, parseEncryptData(message, encode));
+}

package/lib/src/crypto_node.d.ts

@@ -0,0 +1,61 @@
+type HashAlgorithmName = "md5" | SHAHashAlgorithmName;
+type SHAHashAlgorithmName = "sha1" | "sha256" | "sha512";
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export declare function hashDigest(d: string, algorithm?: HashAlgorithmName, upper?: boolean): string;
+/**
+ * 进行 md5|sha1|sha256 数据摘要签名
+ * @param d 待加密的数据
+ * @param algorithm 签名算法, md5、sha1、sha256. Defaults to "sha256".
+ * @param upper 返回的结果是否需要大写. Defaults to False.
+ */
+export declare function hash(d: string, algorithm?: HashAlgorithmName, upper?: boolean): string;
+/**
+ * 使用 HMAC 算法对消息进行哈希处理
+ * @param message 待处理的消息
+ * @param key 用于 HMAC 算法的密钥
+ * @param algorithm 哈希算法，可选值为 "sha1"、"sha256" 或 "sha512"，默认为 "sha256"
+ * @param upper 返回的结果是否需要大写，默认为 false
+ * @returns 经过 HMAC 哈希处理后的字符串
+ */
+export declare function hmacHash(message: string, key: string, algorithm?: SHAHashAlgorithmName, upper?: boolean): string;
+/**
+ * 生成 RSA 签名密钥对
+ * @returns: [公钥, 私钥]
+ */
+export declare function keyPair(): Promise<[string, string]>;
+/**
+ * AES 加密
+ * @param key   加密密钥
+ * @param input 待加密的数据
+ * @param upper 是否转换为大写
+ * @returns [加密数据, 向量]
+ */
+export declare function aesEncrypt(key: string, input: string, upper?: boolean): [string, string];
+/**
+ * AES 解密
+ * @param input 加密后的数据
+ * @param key   密钥
+ * @param iv    向量
+ * @returns
+ */
+export declare function aesDecrypt(input: string, key: string | Buffer, iv?: string | Buffer, algorithm?: string): string;
+/**
+ * RSA 公钥加密
+ * @param input 待加密字符串
+ * @param publicKey 公钥
+ * @returns
+ */
+export declare function rsaEncrypt(input: string, publicKey: string): string;
+/**
+ * RSA 解密
+ * @param encrtypData RSA加密后的数据
+ * @param privateKey  私钥
+ * @returns
+ */
+export declare function rsaDecrypt(encrtypData: string, privateKey: string): string;
+export {};