@ybgnb/utils 0.1.8 → 0.1.9

package/dist/node.js

@@ -1,201 +1,350 @@
-import * as e from "node:fs/promises";
-import t from "node:fs/promises";
-import n from "node:path";
-import { exec as r } from "node:child_process";
-import * as i from "iconv-lite";
-//#region ../src/node/utils/env.ts
-function a() {
-	let e = {};
-	for (let t in process.env) e[t] = process.env[t];
-	return e;
-}
-//#endregion
-//#region ../src/node/utils/file/base.ts
-async function o(e) {
-	try {
-		return (await t.stat(e)).isFile();
-	} catch {
-		return !1;
-	}
-}
-async function s(e, n) {
-	try {
-		return t.access(e, n), !0;
-	} catch {
-		return !1;
-	}
-}
-async function c(e) {
-	t.mkdir(e, { recursive: !0 });
-}
-async function l(e) {
-	await t.mkdir(e, { recursive: !0 });
-}
-function u(e) {
-	return typeof e == "object" && !!e && "code" in e && e.code === "ENOENT";
-}
-//#endregion
-//#region ../src/node/utils/file/delete.ts
-async function d(e) {
-	let r = [], i = await t.readdir(e, { withFileTypes: !0 });
-	for (let a of i) {
-		let i = n.join(e, a.name);
-		a.isDirectory() ? (r.push(...await d(i)), await t.rmdir(i)) : await t.unlink(i), r.push(i);
-	}
-	return r;
-}
-async function f(e) {
-	return (await Promise.allSettled(e.map(async (e) => (await t.unlink(e), e)))).filter((e) => e.status === "fulfilled").map((e) => e.value);
-}
-//#endregion
-//#region ../src/node/utils/file/json.ts
-async function p(e) {
-	if (!await o(e)) throw Error("文件不存在");
-	let r = await t.readFile(n.resolve(e), "utf-8");
-	return JSON.parse(r);
-}
-async function m(e, n) {
-	let r = `${e}.tmp.${Date.now()}`, i = JSON.stringify(n, null, 2);
-	await t.writeFile(r, i, "utf-8"), await t.rename(r, e);
-}
-async function h(e, t) {
-	let n = t(await p(e));
-	return await m(e, n), n;
-}
-async function g(e, r) {
-	try {
-		let n = await t.readFile(e, "utf-8");
-		return JSON.parse(n);
-	} catch (i) {
-		if (!u(i)) throw i;
-		let a = await r();
-		return await l(n.dirname(e)), await t.writeFile(e, JSON.stringify(a, null, 2), "utf-8"), a;
-	}
-}
-//#endregion
-//#region ../src/core/utils/number/format.ts
-function _(e, t, n, r = "") {
-	if (!Number.isFinite(e)) return {
-		size: 0,
-		unit: "",
-		text: r
-	};
-	let i = e, a = 0;
-	for (; i >= t && a < n.length - 1;) i /= t, a++;
-	return {
-		size: i,
-		unit: n[a],
-		text: `${i.toFixed(2).replace(/\.?0+$/, "")} ${n[a]}`
-	};
-}
-//#endregion
-//#region ../src/node/utils/file/size.ts
-function v(e, t = "") {
-	let { size: n, unit: r, text: i } = _(e, 1024, [
-		"KB",
-		"MB",
-		"GB"
-	], t);
-	if (i === t) return t;
-	let a = Math.floor(n), o;
-	return o = a > 99 ? 0 : a > 9 ? 1 : 2, `${Math.round(n * 10 ** o) / 10 ** o} ${r}`;
-}
-async function y(e) {
-	try {
-		return (await t.stat(e)).size;
-	} catch {
-		return 0;
-	}
-}
-async function b(e) {
-	try {
-		return (await t.lstat(e)).size;
-	} catch {
-		return 0;
-	}
-}
-async function x(e) {
-	let r;
-	try {
-		r = await t.readdir(e, { withFileTypes: !0 });
-	} catch {
-		return 0;
-	}
-	let i = [];
-	for (let t of r) {
-		let r = n.join(e, t.name);
-		if (t.isDirectory()) {
-			i.push(x(r));
-			continue;
-		}
-		if (t.isSymbolicLink()) {
-			i.push(b(r));
-			continue;
-		}
-		i.push(y(r));
-	}
-	return (await Promise.allSettled(i)).reduce((e, t) => e + (t.status === "fulfilled" ? t.value : 0), 0);
-}
-async function S(e) {
-	try {
-		let n = await t.stat(e);
-		return n.isDirectory() ? await x(e) / 1024 : n.size / 1024;
-	} catch {
-		return 0;
-	}
-}
-//#endregion
-//#region ../src/core/utils/error.ts
-function C(e) {
-	let t = Error(e ?? "操作已取消");
-	return t.name = "AbortError", t;
-}
-//#endregion
-//#region ../src/node/utils/win/cmd.ts
-async function w(e, t) {
-	return new Promise((n, a) => {
-		if (t?.signal?.aborted) throw C();
-		let o = null, s = r(`${e}`, { encoding: "buffer" }, (e, r, s) => {
-			let c = i.decode(r, "cp936"), l = i.decode(s, "cp936");
-			o && t?.signal?.removeEventListener("abort", o);
-			let u = e ? Number(e.code ?? 0) : 0;
-			(t?.codeIsSuccess ? !t.codeIsSuccess(u) : u !== 0) ? a(/* @__PURE__ */ Error(`命令行执行出错 (${u}): ${l || c}`)) : n(c);
-		}), c;
-		o = () => {
-			s.kill("SIGTERM"), c = setTimeout(() => {
-				s.kill("SIGKILL");
-			}, 3e3), a(C());
-		}, t?.signal && t.signal.addEventListener("abort", o), s.on("close", () => {
-			c !== void 0 && clearTimeout(c), t?.signal?.removeEventListener("abort", o);
-		});
-	});
-}
-//#endregion
-//#region ../src/node/utils/win/copy.ts
-async function T(e, t, r) {
-	let i = n.resolve(e), a = n.resolve(t), s;
-	await o(e) ? (s = `copy "${i}" "${a}"`, await w(s, { signal: r })) : (s = `robocopy "${i}" "${a}" /E /NFL /NDL /NJH /NJS /NC /NS /NP`, await w(s, {
-		codeIsSuccess: (e) => e < 8,
-		signal: r
-	}));
-}
-//#endregion
-//#region ../src/node/utils/win/explorer.ts
-async function E(t) {
-	t = n.resolve(t), (await e.stat(t)).isDirectory() ? await w(`start "" "${t}"`) : await w(`start "" explorer /select,"${t}"`);
-}
-//#endregion
-//#region ../src/node/utils/win/regedit.ts
-async function D(e) {
-	return w(`taskkill /f /im regedit.exe & REG ADD "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit" /v "LastKey" /d "${e}" /f & regedit`);
-}
-async function O(e, t) {
-	t = n.resolve(t), await l(e), await w(`reg export "${e}" "${t}" /y`, void 0);
-}
-async function k(e, t) {
-	await w(`reg import "${n.resolve(t)}"`, void 0);
-}
-//#endregion
-export { T as copyFile, f as deleteFiles, d as emptyDirectory, l as ensureDir, c as ensureDirSync, s as existsFile, O as exportRegedit, v as formatFileSizeFromKB, x as getDirSize, a as getEnv, S as getFileSizeKB, k as importRegedit, o as isFile, u as isFileNotFoundError, D as openRegedit, p as readJSONFile, g as readOrInitJSON, E as showInExplorer, h as updateJSON, m as writeJSONFile };
+// src/node/utils/env.ts
+function getEnv() {
+  const env = {};
+  for (const envKey in process.env) {
+    env[envKey] = process.env[envKey];
+  }
+  return env;
+}
+
+// src/node/utils/file/base.ts
+import fs from "fs/promises";
+async function isFile(filePath) {
+  try {
+    return (await fs.stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function existsFile(file, mode) {
+  try {
+    fs.access(file, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirSync(dirPath) {
+  fs.mkdir(dirPath, { recursive: true });
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+function isFileNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/node/utils/file/delete.ts
+import fs2 from "fs/promises";
+import path from "path";
+async function emptyDirectory(dir) {
+  const deletedPaths = [];
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      deletedPaths.push(...await emptyDirectory(fullPath));
+      await fs2.rmdir(fullPath);
+    } else {
+      await fs2.unlink(fullPath);
+    }
+    deletedPaths.push(fullPath);
+  }
+  return deletedPaths;
+}
+async function deleteFiles(paths) {
+  const results = await Promise.allSettled(
+    paths.map(async (file) => {
+      await fs2.unlink(file);
+      return file;
+    })
+  );
+  return results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+}
+
+// src/node/utils/file/download.ts
+import { pipeline } from "stream/promises";
+import { createWriteStream } from "fs";
+import path2 from "path";
+async function downloadFile(url, filePath) {
+  const file = path2.resolve(filePath);
+  const res = await fetch(url);
+  if (!res.ok || !res.body) {
+    throw new Error(`\u4E0B\u8F7D\u5931\u8D25: ${res.status}`);
+  }
+  await pipeline(res.body, createWriteStream(file));
+}
+
+// src/node/utils/file/find.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function findFilesByPrefixAndSuffix(dir, prefix, suffix) {
+  return (await fs3.readdir(dir, { withFileTypes: true })).filter(
+    (dirent) => (
+      // 仅保留文件（排除子目录）
+      dirent.isFile() && // 文件名匹配前缀
+      dirent.name.startsWith(prefix || "") && // 文件名匹配后缀
+      dirent.name.endsWith(suffix || "")
+    )
+  ).map((dirent) => path3.join(dir, dirent.name));
+}
+async function findFiles(dir, target) {
+  const results = [];
+  const entries = await fs3.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findFiles(fullPath, target));
+    } else if (typeof target === "string" && entry.name === target) {
+      results.push(fullPath);
+    } else if (typeof target === "function" && target(entry.name, fullPath)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/node/utils/file/json.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+async function readJSONFile(filePath) {
+  if (!await isFile(filePath)) {
+    throw new Error("\u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+  const jsonRaw = await fs4.readFile(path4.resolve(filePath), "utf-8");
+  return JSON.parse(jsonRaw);
+}
+async function writeJSONFile(file, data) {
+  const tempFile = `${file}.tmp.${Date.now()}`;
+  const jsonContent = JSON.stringify(data, null, 2);
+  await fs4.writeFile(tempFile, jsonContent, "utf-8");
+  await fs4.rename(tempFile, file);
+}
+async function updateJSON(file, updater) {
+  const oldData = await readJSONFile(file);
+  const newData = updater(oldData);
+  await writeJSONFile(file, newData);
+  return newData;
+}
+async function readOrInitJSON(file, initData) {
+  try {
+    const content = await fs4.readFile(file, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (!isFileNotFoundError(error)) {
+      throw error;
+    }
+    const data = await initData();
+    await ensureDir(path4.dirname(file));
+    await fs4.writeFile(file, JSON.stringify(data, null, 2), "utf-8");
+    return data;
+  }
+}
 
+// src/core/utils/number/format.ts
+function formatUnitSize(value, base, units, invalidText = "") {
+  if (!Number.isFinite(value)) {
+    return { size: 0, unit: "", text: invalidText };
+  }
+  let size = value;
+  let unitIndex = 0;
+  while (size >= base && unitIndex < units.length - 1) {
+    size /= base;
+    unitIndex++;
+  }
+  return {
+    size,
+    unit: units[unitIndex],
+    text: `${size.toFixed(2).replace(/\.?0+$/, "")} ${units[unitIndex]}`
+  };
+}
+
+// src/node/utils/file/size.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+function formatFileSizeFromKB(sizeKB, invalidText = "") {
+  const { size, unit, text } = formatUnitSize(sizeKB, 1024, ["KB", "MB", "GB"], invalidText);
+  if (text === invalidText) {
+    return invalidText;
+  }
+  const integerPart = Math.floor(size);
+  let fractionDigits;
+  if (integerPart > 99) fractionDigits = 0;
+  else if (integerPart > 9) fractionDigits = 1;
+  else fractionDigits = 2;
+  const rounded = Math.round(size * 10 ** fractionDigits) / 10 ** fractionDigits;
+  return `${rounded} ${unit}`;
+}
+async function getFileSize(filePath) {
+  try {
+    const stat2 = await fs5.stat(filePath);
+    return stat2.size;
+  } catch {
+    return 0;
+  }
+}
+async function getSymbolicLinkSize(linkPath) {
+  try {
+    const stat2 = await fs5.lstat(linkPath);
+    return stat2.size;
+  } catch {
+    return 0;
+  }
+}
+async function getDirSize(dir) {
+  let entries;
+  try {
+    entries = await fs5.readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  const tasks = [];
+  for (const entry of entries) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      tasks.push(getDirSize(fullPath));
+      continue;
+    }
+    if (entry.isSymbolicLink()) {
+      tasks.push(getSymbolicLinkSize(fullPath));
+      continue;
+    }
+    tasks.push(getFileSize(fullPath));
+  }
+  const results = await Promise.allSettled(tasks);
+  return results.reduce((total, result) => {
+    return total + (result.status === "fulfilled" ? result.value : 0);
+  }, 0);
+}
+async function getFileSizeKB(filePath) {
+  try {
+    const stat2 = await fs5.stat(filePath);
+    if (stat2.isDirectory()) {
+      return await getDirSize(filePath) / 1024;
+    } else {
+      return stat2.size / 1024;
+    }
+  } catch {
+    return 0;
+  }
+}
+
+// src/core/utils/error.ts
+function createAbortError(msg) {
+  const error = new Error(msg ?? "\u64CD\u4F5C\u5DF2\u53D6\u6D88");
+  error.name = "AbortError";
+  return error;
+}
+
+// src/node/utils/win/cmd.ts
+import { exec } from "child_process";
+import * as iconv from "iconv-lite";
+async function execWinCmd(cmd, options) {
+  return new Promise((resolve, reject) => {
+    if (options?.signal?.aborted) {
+      throw createAbortError();
+    }
+    let abortHandler = null;
+    const child = exec(`${cmd}`, { encoding: "buffer" }, (error, stdout, stderr) => {
+      const stdoutStr = iconv.decode(stdout, "cp936");
+      const stderrStr = iconv.decode(stderr, "cp936");
+      if (abortHandler) {
+        options?.signal?.removeEventListener("abort", abortHandler);
+      }
+      const exitCode = error ? Number(error.code ?? 0) : 0;
+      if (options?.codeIsSuccess ? !options.codeIsSuccess(exitCode) : exitCode !== 0) {
+        reject(new Error(`\u547D\u4EE4\u884C\u6267\u884C\u51FA\u9519 (${exitCode}): ${stderrStr || stdoutStr}`));
+      } else {
+        resolve(stdoutStr);
+      }
+    });
+    let timeout;
+    abortHandler = () => {
+      child.kill("SIGTERM");
+      timeout = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 3e3);
+      reject(createAbortError());
+    };
+    if (options?.signal) {
+      options.signal.addEventListener("abort", abortHandler);
+    }
+    child.on("close", () => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      options?.signal?.removeEventListener("abort", abortHandler);
+    });
+  });
+}
+
+// src/node/utils/win/copy.ts
+import path6 from "path";
+async function copyFile(source, destination, signal) {
+  const src = path6.resolve(source);
+  const dest = path6.resolve(destination);
+  let command;
+  if (await isFile(source)) {
+    command = `copy "${src}" "${dest}"`;
+    await execWinCmd(command, { signal });
+  } else {
+    command = `robocopy "${src}" "${dest}" /E /NFL /NDL /NJH /NJS /NC /NS /NP`;
+    await execWinCmd(command, {
+      codeIsSuccess: (number) => number < 8,
+      signal
+    });
+  }
+}
+
+// src/node/utils/win/explorer.ts
+import path7 from "path";
+import * as fs6 from "fs/promises";
+async function showInExplorer(fileOrDir) {
+  fileOrDir = path7.resolve(fileOrDir);
+  if ((await fs6.stat(fileOrDir)).isDirectory()) {
+    await execWinCmd(`start "" "${fileOrDir}"`);
+  } else {
+    await execWinCmd(`start "" explorer /select,"${fileOrDir}"`);
+  }
+}
+
+// src/node/utils/win/regedit.ts
+import path8 from "path";
+async function openRegedit(path9) {
+  return execWinCmd(
+    `taskkill /f /im regedit.exe & REG ADD "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit" /v "LastKey" /d "${path9}" /f & regedit`
+  );
+}
+async function exportRegedit(regPath, filePath) {
+  filePath = path8.resolve(filePath);
+  await ensureDir(regPath);
+  await execWinCmd(`reg export "${regPath}" "${filePath}" /y`, void 0);
+}
+async function importRegedit(regPath, filePath) {
+  await execWinCmd(`reg import "${path8.resolve(filePath)}"`, void 0);
+}
+export {
+  copyFile,
+  deleteFiles,
+  downloadFile,
+  emptyDirectory,
+  ensureDir,
+  ensureDirSync,
+  execWinCmd,
+  existsFile,
+  exportRegedit,
+  findFiles,
+  findFilesByPrefixAndSuffix,
+  formatFileSizeFromKB,
+  getDirSize,
+  getEnv,
+  getFileSizeKB,
+  importRegedit,
+  isFile,
+  isFileNotFoundError,
+  openRegedit,
+  readJSONFile,
+  readOrInitJSON,
+  showInExplorer,
+  updateJSON,
+  writeJSONFile
+};
 //# sourceMappingURL=node.js.map