ph-utils 0.4.8 → 0.5.0

package/lib/crypto.d.ts

@@ -14,7 +14,7 @@ export declare function bufferToHex(bf: ArrayBuffer | Uint8Array, upper?: boolea
  */
 export declare function sha(message: string, upper?: boolean, algorithm?: string): Promise<string>;
 /** 返回结果类似 */
-type AlgorithmResType = 'hex' | 'hexUpper' | 'base64' | 'raw';
+type AlgorithmResType = "hex" | "hexUpper" | "base64" | "raw";
 /**
  * AES 加密
  * @param message 待加密的数据

package/lib/crypto.js

@@ -10,10 +10,10 @@ export function bufferToHex(bf, upper = false) {
     const hashArray = Array.from(u8Array);
     return hashArray
         .map((b) => {
-        let hx = b.toString(16).padStart(2, '0');
+        let hx = b.toString(16).padStart(2, "0");
         return upper === true ? hx.toUpperCase() : hx;
     })
-        .join('');
+        .join("");
 }
 /**
  * 将16进制的数据转换为 UInt8Array
@@ -38,7 +38,7 @@ function hexToBuffer(data) {
 function bufferToBase64(bf) {
     const u8Array = bf instanceof Uint8Array ? bf : new Uint8Array(bf);
     const hashArray = Array.from(u8Array);
-    return window.btoa(String.fromCharCode.apply(null, hashArray));
+    return globalThis.btoa(String.fromCharCode.apply(null, hashArray));
 }
 /**
  * 将 Base64 转换为 UInt8Array 数据
@@ -46,9 +46,9 @@ function bufferToBase64(bf) {
  * @returns
  */
 function base64ToBuffer(data) {
-    return new Uint8Array(window
+    return new Uint8Array(globalThis
         .atob(data)
-        .split('')
+        .split("")
         .map((char) => char.charCodeAt(0)));
 }
 /**
@@ -58,14 +58,14 @@ function base64ToBuffer(data) {
  * @param algorithm   hash算法, 支持: SHA-1、SHA-256、SHA-384、SHA-512; 默认为: SHA-256
  * @returns
  */
-export async function sha(message, upper = false, algorithm = 'SHA-256') {
+export async function sha(message, upper = false, algorithm = "SHA-256") {
     const msgUint8 = new TextEncoder().encode(message);
-    const hashBuffer = await window.crypto.subtle.digest(algorithm || 'SHA-256', msgUint8);
+    const hashBuffer = await globalThis.crypto.subtle.digest(algorithm || "SHA-256", msgUint8);
     return bufferToHex(hashBuffer, upper);
 }
 function parseRsaKey(pem) {
-    const pemHeader = '-----BEGIN PUBLIC KEY-----';
-    const pemFooter = '-----END PUBLIC KEY-----';
+    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();
     }
@@ -79,34 +79,34 @@ function parseRsaKey(pem) {
  * @returns
  */
 // eslint-disable-next-line no-undef
-async function importKey(key, algorithmName, usages, encoding = 'hex') {
-    let name = 'AES-CBC';
+async function importKey(key, algorithmName, usages, encoding = "hex") {
+    let name = "AES-CBC";
     if (algorithmName == null) {
-        name = 'AES-CBC';
+        name = "AES-CBC";
     }
     else {
-        if (algorithmName.toUpperCase() === 'AES') {
-            name = 'AES-CBC';
+        if (algorithmName.toUpperCase() === "AES") {
+            name = "AES-CBC";
         }
-        else if (algorithmName.toUpperCase() === 'RSA') {
-            name = 'RSA-OAEP';
+        else if (algorithmName.toUpperCase() === "RSA") {
+            name = "RSA-OAEP";
         }
     }
     name = name.toUpperCase();
     if (usages == null || usages.length === 0) {
-        usages = ['encrypt'];
+        usages = ["encrypt"];
     }
-    let format = 'raw';
+    let format = "raw";
     let algorithm = { name };
-    if (name.includes('RSA')) {
-        format = 'spki';
-        algorithm.hash = { name: 'SHA-256' };
+    if (name.includes("RSA")) {
+        format = "spki";
+        algorithm.hash = { name: "SHA-256" };
         key = parseRsaKey(key);
     }
-    const keyBuf = encoding === 'base64' ? base64ToBuffer(key) : hexToBuffer(key);
+    const keyBuf = encoding === "base64" ? base64ToBuffer(key) : hexToBuffer(key);
     // importKey时传 false 表明该密钥不能被导出
     return Promise.all([
-        window.crypto.subtle.importKey(format, keyBuf, algorithm, false, usages),
+        globalThis.crypto.subtle.importKey(format, keyBuf, algorithm, false, usages),
         Promise.resolve({ name }),
     ]);
 }
@@ -118,18 +118,18 @@ async function importKey(key, algorithmName, usages, encoding = 'hex') {
  * @param encode     解密后返回数据格式
  * @returns
  */
-async function encrypt(algorithm, key, message, encode = 'hex') {
-    if (typeof message === 'string') {
+async function encrypt(algorithm, key, message, encode = "hex") {
+    if (typeof message === "string") {
         message = new TextEncoder().encode(message);
     }
-    const encrypted = await window.crypto.subtle.encrypt(algorithm, key, message);
-    if (encode === 'hex') {
+    const encrypted = await globalThis.crypto.subtle.encrypt(algorithm, key, message);
+    if (encode === "hex") {
         return bufferToHex(encrypted);
     }
-    else if (encode === 'hexUpper') {
+    else if (encode === "hexUpper") {
         return bufferToHex(encrypted, true);
     }
-    else if (encode === 'base64') {
+    else if (encode === "base64") {
         return bufferToBase64(encrypted);
     }
     else {
@@ -144,8 +144,8 @@ async function encrypt(algorithm, key, message, encode = 'hex') {
  * @returns
  */
 async function decrypt(algorithm, key, message) {
-    const decrypted = await window.crypto.subtle.decrypt(algorithm, key, message);
-    return new TextDecoder('utf-8').decode(decrypted);
+    const decrypted = await globalThis.crypto.subtle.decrypt(algorithm, key, message);
+    return new TextDecoder("utf-8").decode(decrypted);
 }
 /**
  * AES 加密
@@ -155,15 +155,15 @@ async function decrypt(algorithm, key, message) {
  * @param iv 加解密向量
  * @returns [加密数据,向量]
  */
-export async function aesEncrypt(message, key, encode = 'hex', iv = null) {
-    let ciphertext = '';
-    let resIv = '';
+export async function aesEncrypt(message, key, encode = "hex", iv = null) {
+    let ciphertext = "";
+    let resIv = "";
     // 导入密钥
-    const [cryptoKey, algorithm] = await importKey(key, 'aes', ['encrypt']);
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["encrypt"]);
     if (iv == null) {
-        iv = window.crypto.getRandomValues(new Uint8Array(16));
+        iv = globalThis.crypto.getRandomValues(new Uint8Array(16));
     }
-    else if (typeof iv === 'string') {
+    else if (typeof iv === "string") {
         iv = hexToBuffer(iv);
     }
     const encodeData = await encrypt({ ...algorithm, iv }, cryptoKey, message, encode);
@@ -179,8 +179,8 @@ export async function aesEncrypt(message, key, encode = 'hex', iv = null) {
  */
 function parseEncryptData(message, type) {
     let input;
-    if (typeof message === 'string') {
-        if (type === 'hex' || type === 'hexUpper') {
+    if (typeof message === "string") {
+        if (type === "hex" || type === "hexUpper") {
             input = hexToBuffer(message);
         }
         else {
@@ -200,9 +200,9 @@ function parseEncryptData(message, type) {
  * @param encode  加密后数据的形式: hex | base64
  * @returns
  */
-export async function aesDecrypt(message, key, iv, encode = 'hex') {
+export async function aesDecrypt(message, key, iv, encode = "hex") {
     // 导入密钥
-    const [cryptoKey, algorithm] = await importKey(key, 'aes', ['decrypt']);
+    const [cryptoKey, algorithm] = await importKey(key, "aes", ["decrypt"]);
     const input = parseEncryptData(message, encode);
     return await decrypt({ ...algorithm, iv: hexToBuffer(iv) }, cryptoKey, input);
 }
@@ -213,9 +213,9 @@ export async function aesDecrypt(message, key, iv, encode = 'hex') {
  * @param encode  返回类型
  * @returns
  */
-export async function rsaEncrypt(message, publicKey, encode = 'hex') {
+export async function rsaEncrypt(message, publicKey, encode = "hex") {
     // 导入密钥
-    const [cryptoKey, algorithm] = await importKey(publicKey, 'rsa', ['encrypt'], 'base64');
+    const [cryptoKey, algorithm] = await importKey(publicKey, "rsa", ["encrypt"], "base64");
     return await encrypt(algorithm, cryptoKey, message, encode);
 }
 /**
@@ -225,8 +225,10 @@ export async function rsaEncrypt(message, publicKey, encode = 'hex') {
  * @param encode  加密后的数据形式
  * @returns
  */
-export async function rsaDecrypt(privateKey, message, encode = 'hex') {
+export async function rsaDecrypt(privateKey, message, encode = "hex") {
     // 导入密钥
-    const [cryptoKey, algorithm] = await importKey(privateKey, 'rsa', ['decrypt']);
+    const [cryptoKey, algorithm] = await importKey(privateKey, "rsa", [
+        "decrypt",
+    ]);
     return await decrypt({ ...algorithm }, cryptoKey, parseEncryptData(message, encode));
 }

package/lib/file.d.ts

@@ -1,9 +1,14 @@
 /**
  * 读取文件内容为JSON格式
  * @param filepath 读取的文件路径
+ * @param errIsNull 读取失败时，是否返回 null，默认为 false[抛出异常]
+ *
+ * @example <caption>1. 文件不存在时, 返回null，而不是 catch</caption>
+ * await readJSON("./not-exists.json", true);
+ *
  * @returns Promise<unknown>
  */
-export declare function readJSON<T>(filepath: string): Promise<T>;
+export declare function readJSON<T>(filepath: string, errIsNull?: boolean): Promise<T>;
 /**
  * 写入 JSON 格式的数据到文件
  * @param file 待写入的文件
@@ -16,13 +21,6 @@ export declare function write(file: string, data: any, opts?: {
     json: boolean;
     format: boolean;
 }): Promise<unknown>;
-/**
- * 遍历文件夹
- * @param dir 待遍历的目录
- * @param callback 遍历到文件后的回调
- * @param done 遍历完成后的回调
- */
-export declare function traverseDir(dir: string, callback?: (filename: string) => void, done?: () => void): void;
 /**
  * 根据文件的 stat 获取文件的 etag
  * @param filePath 文件地址

package/lib/file.js

@@ -4,13 +4,23 @@ import fs from "node:fs";
 /**
  * 读取文件内容为JSON格式
  * @param filepath 读取的文件路径
+ * @param errIsNull 读取失败时，是否返回 null，默认为 false[抛出异常]
+ *
+ * @example <caption>1. 文件不存在时, 返回null，而不是 catch</caption>
+ * await readJSON("./not-exists.json", true);
+ *
  * @returns Promise<unknown>
  */
-export function readJSON(filepath) {
+export function readJSON(filepath, errIsNull = false) {
     return new Promise((resolve, reject) => {
         fs.readFile(path.resolve(filepath), "utf-8", (err, data) => {
             if (err) {
-                reject(err);
+                if (errIsNull) {
+                    resolve(null);
+                }
+                else {
+                    reject(err);
+                }
             }
             else {
                 resolve(JSON.parse(data));
@@ -43,48 +53,6 @@ export function write(file, data, opts) {
         });
     });
 }
-/**
- * 遍历文件夹
- * @param dir 待遍历的目录
- * @param callback 遍历到文件后的回调
- * @param done 遍历完成后的回调
- */
-export function traverseDir(dir, callback, done) {
-    let t = -1; // 定时任务，简单延迟作为遍历完成计算
-    function list(dr, cb, d) {
-        fs.readdir(path.resolve(dr), { withFileTypes: true }, (err, files) => {
-            if (err && err.errno === -4052) {
-                // 本身就是文件
-                if (typeof cb === "function")
-                    cb(dr);
-                if (typeof d === "function")
-                    d(); // 遍历完成
-            }
-            else {
-                for (let i = 0, len = files.length; i < len; i++) {
-                    const file = files[i];
-                    if (file.isFile()) {
-                        if (typeof cb === "function")
-                            cb(path.join(dr, file.name));
-                        clearTimeout(t);
-                        t = setTimeout(() => {
-                            setImmediate(() => {
-                                if (typeof done === "function") {
-                                    done();
-                                }
-                            });
-                        }, 10);
-                    }
-                    else {
-                        // 文件夹
-                        list(path.join(dr, file.name), cb, d);
-                    }
-                }
-            }
-        });
-    }
-    list(dir, callback, done);
-}
 /**
  * 根据文件的 stat 获取文件的 etag
  * @param filePath 文件地址

package/package.json

@@ -52,7 +52,7 @@
     },
     "./*": "./lib/*"
   },
-  "version": "0.4.8",
+  "version": "0.5.0",
   "type": "module",
   "repository": {
     "type": "git",