soda-nodejs 0.8.2 → 0.8.3

package/README.md

@@ -1,23 +1,23 @@
-# soda-node
-
-[![NPM version](https://img.shields.io/npm/v/soda-node.svg?style=flat)](https://npmjs.com/package/soda-node)
-[![NPM downloads](http://img.shields.io/npm/dm/soda-node.svg?style=flat)](https://npmjs.com/package/soda-node)
-
-## Install
-
-```bash
-$ pnpm install
-```
-
-```bash
-$ npm run dev
-$ npm run build
-```
-
-## Options
-
-TODO
-
-## LICENSE
-
-MIT
+# soda-node
+
+[![NPM version](https://img.shields.io/npm/v/soda-node.svg?style=flat)](https://npmjs.com/package/soda-node)
+[![NPM downloads](http://img.shields.io/npm/dm/soda-node.svg?style=flat)](https://npmjs.com/package/soda-node)
+
+## Install
+
+```bash
+$ pnpm install
+```
+
+```bash
+$ npm run dev
+$ npm run build
+```
+
+## Options
+
+TODO
+
+## LICENSE
+
+MIT

package/dist/utils/compress.js

@@ -1,20 +1,20 @@
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
-import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
-import * as __WEBPACK_EXTERNAL_MODULE_tar__ from "tar";
+import { existsSync, mkdirSync } from "fs";
+import { basename, dirname, resolve } from "path";
+import { create } from "tar";
 async function compress({ input, output }) {
-    input = (0, __WEBPACK_EXTERNAL_MODULE_path__.resolve)(input);
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(input)) throw new Error("Source folder does not exist");
-    const outputDir = (0, __WEBPACK_EXTERNAL_MODULE_path__.dirname)(output);
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(outputDir)) (0, __WEBPACK_EXTERNAL_MODULE_fs__.mkdirSync)(outputDir, {
+    input = resolve(input);
+    if (!existsSync(input)) throw new Error("Source folder does not exist");
+    const outputDir = dirname(output);
+    if (!existsSync(outputDir)) mkdirSync(outputDir, {
         recursive: true
     });
-    await (0, __WEBPACK_EXTERNAL_MODULE_tar__.create)({
+    await create({
         gzip: true,
         file: output,
-        cwd: (0, __WEBPACK_EXTERNAL_MODULE_path__.dirname)(input)
+        cwd: dirname(input)
     }, [
-        (0, __WEBPACK_EXTERNAL_MODULE_path__.basename)(input)
+        basename(input)
     ]);
-    return (0, __WEBPACK_EXTERNAL_MODULE_path__.resolve)(output);
+    return resolve(output);
 }
 export { compress };

package/dist/utils/copy.cjs

@@ -43,10 +43,7 @@ async function copy({ input, output, mode }) {
     });
     const status = await (0, promises_namespaceObject.stat)(input);
     const { base } = (0, external_path_namespaceObject.parse)(input);
-    if (status.isFile()) {
-        await (0, promises_namespaceObject.copyFile)(input, (0, external_path_namespaceObject.join)(output, base), mode);
-        return;
-    }
+    if (status.isFile()) return void await (0, promises_namespaceObject.copyFile)(input, (0, external_path_namespaceObject.join)(output, base), mode);
     if (status.isDirectory()) {
         await (0, promises_namespaceObject.mkdir)((0, external_path_namespaceObject.join)(output, base), {
             recursive: true

package/dist/utils/copy.js

@@ -1,6 +1,6 @@
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
-import * as __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__ from "fs/promises";
-import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import { existsSync } from "fs";
+import { copyFile, mkdir, readdir, stat } from "fs/promises";
+import { join, parse } from "path";
 async function copy({ input, output, mode }) {
     if (Array.isArray(input)) {
         for (const item of input)await copy({
@@ -10,25 +10,22 @@ async function copy({ input, output, mode }) {
         });
         return;
     }
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_fs__.existsSync)(output)) await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.mkdir)(output, {
+    if (!existsSync(output)) await mkdir(output, {
         recursive: true
     });
-    const status = await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.stat)(input);
-    const { base } = (0, __WEBPACK_EXTERNAL_MODULE_path__.parse)(input);
-    if (status.isFile()) {
-        await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.copyFile)(input, (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base), mode);
-        return;
-    }
+    const status = await stat(input);
+    const { base } = parse(input);
+    if (status.isFile()) return void await copyFile(input, join(output, base), mode);
     if (status.isDirectory()) {
-        await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.mkdir)((0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base), {
+        await mkdir(join(output, base), {
             recursive: true
         });
-        const entries = await (0, __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__.readdir)(input, {
+        const entries = await readdir(input, {
             withFileTypes: true
         });
         for (const entry of entries)await copy({
-            input: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(input, entry.name),
-            output: (0, __WEBPACK_EXTERNAL_MODULE_path__.join)(output, base),
+            input: join(input, entry.name),
+            output: join(output, base),
             mode
         });
     }

package/dist/utils/execAsync.js

@@ -1,5 +1,5 @@
-import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
-import * as __WEBPACK_EXTERNAL_MODULE_iconv_lite_e3756a92__ from "iconv-lite";
+import { exec } from "child_process";
+import iconv_lite from "iconv-lite";
 async function execAsync(command, options) {
     const decode = options?.decode;
     if ("object" == typeof options && null !== options && options.decode) {
@@ -7,9 +7,9 @@ async function execAsync(command, options) {
         options = rest;
     }
     return await new Promise((resolve, reject)=>{
-        (0, __WEBPACK_EXTERNAL_MODULE_child_process__.exec)(command, options, (error, stdout, stderr)=>{
+        exec(command, options, (error, stdout, stderr)=>{
             if (error) return reject(error);
-            if (decode && stdout instanceof Buffer) return resolve(__WEBPACK_EXTERNAL_MODULE_iconv_lite_e3756a92__["default"].decode(stdout, decode.encoding, decode.options));
+            if (decode && stdout instanceof Buffer) return resolve(iconv_lite.decode(stdout, decode.encoding, decode.options));
             resolve(stdout);
         });
     });

package/dist/utils/saveFile.js

@@ -1,9 +1,9 @@
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
-import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+import { createWriteStream } from "fs";
+import { Readable } from "stream";
 async function saveFile({ input, output }) {
     await new Promise((resolve, reject)=>{
-        const writeAble = (0, __WEBPACK_EXTERNAL_MODULE_fs__.createWriteStream)(output);
-        __WEBPACK_EXTERNAL_MODULE_stream__.Readable.fromWeb(input.stream()).pipe(writeAble).on("finish", resolve).on("error", reject);
+        const writeAble = createWriteStream(output);
+        Readable.fromWeb(input.stream()).pipe(writeAble).on("finish", resolve).on("error", reject);
     });
 }
 export { saveFile };

package/dist/utils/saveResponse.js

@@ -1,7 +1,7 @@
-import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
-import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+import { createWriteStream } from "fs";
+import { Readable } from "stream";
 async function saveResponse(response, file) {
-    const writeable = (0, __WEBPACK_EXTERNAL_MODULE_fs__.createWriteStream)(file);
-    await new Promise((resolve, reject)=>__WEBPACK_EXTERNAL_MODULE_stream__.Readable.fromWeb(response.body).pipe(writeable).on("close", resolve).on("error", reject));
+    const writeable = createWriteStream(file);
+    await new Promise((resolve, reject)=>Readable.fromWeb(response.body).pipe(writeable).on("close", resolve).on("error", reject));
 }
 export { saveResponse };

package/dist/utils/spawnAsync.cjs

@@ -25,8 +25,8 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getDefaultOptions: ()=>getDefaultOptions,
-    spawnAsync: ()=>spawnAsync,
-    setDefaultOptions: ()=>setDefaultOptions
+    setDefaultOptions: ()=>setDefaultOptions,
+    spawnAsync: ()=>spawnAsync
 });
 const external_child_process_namespaceObject = require("child_process");
 let defaultOptions = {};

package/dist/utils/spawnAsync.js

@@ -1,4 +1,4 @@
-import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+import { spawn } from "child_process";
 let defaultOptions = {};
 function getDefaultOptions() {
     return defaultOptions;
@@ -22,7 +22,7 @@ function spawnAsync(command, args, options) {
             ...defaultOptions,
             ...args
         };
-        child = (0, __WEBPACK_EXTERNAL_MODULE_child_process__.spawn)(command, args, options);
+        child = spawn(command, args, options);
         child.on("exit", (code)=>{
             if (0 === code) return resolve(child);
             if (Array.isArray(args)) {

package/dist/utils/unzip.js

@@ -1,8 +1,8 @@
-import * as __WEBPACK_EXTERNAL_MODULE_which__ from "which";
-import * as __WEBPACK_EXTERNAL_MODULE__execAsync_js_bec93fa3__ from "./execAsync.js";
+import which from "which";
+import { execAsync } from "./execAsync.js";
 async function unzip({ input, output, cwd }) {
-    await (0, __WEBPACK_EXTERNAL_MODULE_which__["default"])("7z");
-    return await (0, __WEBPACK_EXTERNAL_MODULE__execAsync_js_bec93fa3__.execAsync)(`7z x ${input} -o${output}`, {
+    await which("7z");
+    return await execAsync(`7z x ${input} -o${output}`, {
         cwd
     });
 }

package/dist/utils/zip.js

@@ -1,11 +1,11 @@
-import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
-import * as __WEBPACK_EXTERNAL_MODULE_which__ from "which";
-import * as __WEBPACK_EXTERNAL_MODULE__execAsync_js_bec93fa3__ from "./execAsync.js";
+import { cpus } from "os";
+import which from "which";
+import { execAsync } from "./execAsync.js";
 async function zip({ input, output, thread = "auto", level, password, cwd }) {
-    await (0, __WEBPACK_EXTERNAL_MODULE_which__["default"])("7z");
+    await which("7z");
     input = Array.isArray(input) ? input.join(" ") : input;
-    if ("max" === thread) thread = (0, __WEBPACK_EXTERNAL_MODULE_os__.cpus)().length;
-    return await (0, __WEBPACK_EXTERNAL_MODULE__execAsync_js_bec93fa3__.execAsync)(`7z a ${output} ${input} -mmt=${"auto" === thread ? "on" : thread}${"number" == typeof level ? ` -mx=${level}` : ""}${password ? ` -p${password}` : ""}`, {
+    if ("max" === thread) thread = cpus().length;
+    return await execAsync(`7z a ${output} ${input} -mmt=${"auto" === thread ? "on" : thread}${"number" == typeof level ? ` -mx=${level}` : ""}${password ? ` -p${password}` : ""}`, {
         cwd
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soda-nodejs",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "",
   "type": "module",
   "exports": {
@@ -40,9 +40,9 @@
     "which": "^5.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.16.3",
+    "@types/node": "^22.17.0",
     "@types/which": "^3.0.4",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "peerDependencies": {},
   "scripts": {

package/src/utils/compress.ts

@@ -1,37 +1,37 @@
-import { existsSync, mkdirSync } from "fs"
-import { basename, dirname, resolve } from "path"
-import { create } from "tar"
-
-export interface CompressionParams {
-    /**
-     * 需要压缩的文件夹
-     */
-    input: string
-    /**
-     * 压缩后的文件路径
-     */
-    output: string
-}
-
-export async function compress({ input, output }: CompressionParams) {
-    input = resolve(input)
-
-    // 确保源路径存在
-    if (!existsSync(input)) throw new Error("Source folder does not exist")
-
-    // 确保输出目录存在
-    const outputDir = dirname(output)
-    if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true })
-
-    // 执行压缩
-    await create(
-        {
-            gzip: true, // 使用 gzip 压缩
-            file: output, // 输出文件路径
-            cwd: dirname(input), // 设置工作目录
-        },
-        [basename(input)], // 要压缩的文件夹名
-    )
-
-    return resolve(output)
-}
+import { existsSync, mkdirSync } from "fs"
+import { basename, dirname, resolve } from "path"
+import { create } from "tar"
+
+export interface CompressionParams {
+    /**
+     * 需要压缩的文件夹
+     */
+    input: string
+    /**
+     * 压缩后的文件路径
+     */
+    output: string
+}
+
+export async function compress({ input, output }: CompressionParams) {
+    input = resolve(input)
+
+    // 确保源路径存在
+    if (!existsSync(input)) throw new Error("Source folder does not exist")
+
+    // 确保输出目录存在
+    const outputDir = dirname(output)
+    if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true })
+
+    // 执行压缩
+    await create(
+        {
+            gzip: true, // 使用 gzip 压缩
+            file: output, // 输出文件路径
+            cwd: dirname(input), // 设置工作目录
+        },
+        [basename(input)], // 要压缩的文件夹名
+    )
+
+    return resolve(output)
+}

package/src/utils/copy.ts

@@ -1,37 +1,37 @@
-import { existsSync } from "fs"
-import { copyFile, mkdir, readdir, stat } from "fs/promises"
-import { join, parse } from "path"
-
-export type CopyOptions = {
-    /** 源文件夹 */
-    input: string | string[]
-    /** 存放的文件夹 */
-    output: string
-    /** 文件权限 */
-    mode?: number
-}
-
-export async function copy({ input, output, mode }: CopyOptions) {
-    if (Array.isArray(input)) {
-        for (const item of input) await copy({ input: item, output, mode })
-        return
-    }
-    if (!existsSync(output)) await mkdir(output, { recursive: true })
-    const status = await stat(input)
-    const { base } = parse(input)
-    if (status.isFile()) {
-        await copyFile(input, join(output, base), mode)
-        return
-    }
-    if (status.isDirectory()) {
-        await mkdir(join(output, base), { recursive: true })
-        const entries = await readdir(input, { withFileTypes: true })
-        for (const entry of entries) {
-            await copy({
-                input: join(input, entry.name),
-                output: join(output, base),
-                mode,
-            })
-        }
-    }
-}
+import { existsSync } from "fs"
+import { copyFile, mkdir, readdir, stat } from "fs/promises"
+import { join, parse } from "path"
+
+export type CopyOptions = {
+    /** 源文件夹 */
+    input: string | string[]
+    /** 存放的文件夹 */
+    output: string
+    /** 文件权限 */
+    mode?: number
+}
+
+export async function copy({ input, output, mode }: CopyOptions) {
+    if (Array.isArray(input)) {
+        for (const item of input) await copy({ input: item, output, mode })
+        return
+    }
+    if (!existsSync(output)) await mkdir(output, { recursive: true })
+    const status = await stat(input)
+    const { base } = parse(input)
+    if (status.isFile()) {
+        await copyFile(input, join(output, base), mode)
+        return
+    }
+    if (status.isDirectory()) {
+        await mkdir(join(output, base), { recursive: true })
+        const entries = await readdir(input, { withFileTypes: true })
+        for (const entry of entries) {
+            await copy({
+                input: join(input, entry.name),
+                output: join(output, base),
+                mode,
+            })
+        }
+    }
+}

package/src/utils/execAsync.ts

@@ -1,36 +1,36 @@
-import { ExecOptions, exec } from "child_process"
-import { ObjectEncodingOptions } from "fs"
-import iconv, { Options } from "iconv-lite"
-
-export type IconvDecodeOptions = {
-    encoding: string
-    options?: Options
-}
-
-export async function execAsync(command: string): Promise<string>
-export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions): Promise<Buffer>
-export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions & { decode: IconvDecodeOptions }): Promise<string>
-export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<string>
-export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<string | Buffer>
-export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions & { decode: IconvDecodeOptions }): Promise<string>
-export async function execAsync(command: string, options: ExecOptions): Promise<string>
-export async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<string | Buffer>
-export async function execAsync(
-    command: string,
-    options: (ObjectEncodingOptions & ExecOptions & { decode: IconvDecodeOptions }) | undefined | null,
-): Promise<string>
-export async function execAsync(command: string, options?: any) {
-    const decode = options?.decode as IconvDecodeOptions | undefined
-    if (typeof options === "object" && options !== null && options.decode) {
-        const { decode, ...rest } = options as { decode: IconvDecodeOptions }
-        options = rest
-    }
-    return await new Promise<string | Buffer>((resolve, reject) => {
-        exec(command, options, (error, stdout, stderr) => {
-            if (error) return reject(error)
-            // if (stderr) console.warn(stderr)
-            if (decode && stdout instanceof Buffer) return resolve(iconv.decode(stdout, decode.encoding, decode.options))
-            resolve(stdout)
-        })
-    })
-}
+import { ExecOptions, exec } from "child_process"
+import { ObjectEncodingOptions } from "fs"
+import iconv, { Options } from "iconv-lite"
+
+export type IconvDecodeOptions = {
+    encoding: string
+    options?: Options
+}
+
+export async function execAsync(command: string): Promise<string>
+export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions): Promise<Buffer>
+export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions & { decode: IconvDecodeOptions }): Promise<string>
+export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<string>
+export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<string | Buffer>
+export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions & { decode: IconvDecodeOptions }): Promise<string>
+export async function execAsync(command: string, options: ExecOptions): Promise<string>
+export async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<string | Buffer>
+export async function execAsync(
+    command: string,
+    options: (ObjectEncodingOptions & ExecOptions & { decode: IconvDecodeOptions }) | undefined | null,
+): Promise<string>
+export async function execAsync(command: string, options?: any) {
+    const decode = options?.decode as IconvDecodeOptions | undefined
+    if (typeof options === "object" && options !== null && options.decode) {
+        const { decode, ...rest } = options as { decode: IconvDecodeOptions }
+        options = rest
+    }
+    return await new Promise<string | Buffer>((resolve, reject) => {
+        exec(command, options, (error, stdout, stderr) => {
+            if (error) return reject(error)
+            // if (stderr) console.warn(stderr)
+            if (decode && stdout instanceof Buffer) return resolve(iconv.decode(stdout, decode.encoding, decode.options))
+            resolve(stdout)
+        })
+    })
+}

package/src/utils/saveFile.ts

@@ -1,22 +1,22 @@
-import { createWriteStream } from "fs"
-import { Readable } from "stream"
-
-export type SaveFileOptions = {
-    /** 要保存的文件 */
-    input: File
-    /** 保存文件的目标位置 */
-    output: string
-}
-
-/**
- * 保存文件
- */
-export async function saveFile({ input, output }: SaveFileOptions) {
-    await new Promise<void>((resolve, reject) => {
-        const writeAble = createWriteStream(output)
-        Readable.fromWeb(input.stream() as any)
-            .pipe(writeAble)
-            .on("finish", resolve)
-            .on("error", reject)
-    })
-}
+import { createWriteStream } from "fs"
+import { Readable } from "stream"
+
+export type SaveFileOptions = {
+    /** 要保存的文件 */
+    input: File
+    /** 保存文件的目标位置 */
+    output: string
+}
+
+/**
+ * 保存文件
+ */
+export async function saveFile({ input, output }: SaveFileOptions) {
+    await new Promise<void>((resolve, reject) => {
+        const writeAble = createWriteStream(output)
+        Readable.fromWeb(input.stream() as any)
+            .pipe(writeAble)
+            .on("finish", resolve)
+            .on("error", reject)
+    })
+}

package/src/utils/saveResponse.ts

@@ -1,17 +1,17 @@
-import { createWriteStream } from "fs"
-import { Readable } from "stream"
-
-/**
- * 从 Response 对象中下载文件
- * @param response Response 对象
- * @param file 文件路径
- */
-export async function saveResponse(response: Response, file: string) {
-    const writeable = createWriteStream(file)
-    await new Promise<void>((resolve, reject) =>
-        Readable.fromWeb(response.body! as any)
-            .pipe(writeable)
-            .on("close", resolve)
-            .on("error", reject),
-    )
-}
+import { createWriteStream } from "fs"
+import { Readable } from "stream"
+
+/**
+ * 从 Response 对象中下载文件
+ * @param response Response 对象
+ * @param file 文件路径
+ */
+export async function saveResponse(response: Response, file: string) {
+    const writeable = createWriteStream(file)
+    await new Promise<void>((resolve, reject) =>
+        Readable.fromWeb(response.body! as any)
+            .pipe(writeable)
+            .on("close", resolve)
+            .on("error", reject),
+    )
+}

package/src/utils/spawnAsync.ts

@@ -1,156 +1,156 @@
-import {
-    ChildProcess,
-    ChildProcessByStdio,
-    ChildProcessWithoutNullStreams,
-    SpawnOptions,
-    SpawnOptionsWithStdioTuple,
-    SpawnOptionsWithoutStdio,
-    StdioNull,
-    StdioPipe,
-    spawn,
-} from "child_process"
-import { Readable, Writable } from "stream"
-
-export interface PromiseWithChildProcess<T> extends Promise<T> {
-    child: T
-}
-
-export type Options =
-    | SpawnOptionsWithoutStdio
-    | SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>
-    | SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>
-    | SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>
-    | SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>
-    | SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>
-    | SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>
-    | SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>
-    | SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>
-    | SpawnOptions
-
-let defaultOptions: Options = {}
-
-/**
- * @description get default options for spawnAsync
- * @returns {Options} options
- */
-export function getDefaultOptions(): Options {
-    return defaultOptions
-}
-
-/**
- * @description set default options for spawnAsync
- * @param  {Options | ((prev: Options) => Options)} options
- */
-export function setDefaultOptions(options: Options | ((prev: Options) => Options)) {
-    if (typeof options === "function") {
-        defaultOptions = options(defaultOptions)
-        return
-    }
-    defaultOptions = options
-    return defaultOptions
-}
-
-export function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): PromiseWithChildProcess<ChildProcessWithoutNullStreams>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, Readable>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, null>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, Readable>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, Readable>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, null>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, null>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, null, Readable>>
-export function spawnAsync(
-    command: string,
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, null, null>>
-export function spawnAsync(command: string, options: SpawnOptions): PromiseWithChildProcess<ChildProcess>
-export function spawnAsync(
-    command: string,
-    args?: readonly string[],
-    options?: SpawnOptionsWithoutStdio,
-): PromiseWithChildProcess<ChildProcessWithoutNullStreams>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, Readable>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, null>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, Readable>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, Readable>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, null>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, null>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, null, Readable>>
-export function spawnAsync(
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>,
-): PromiseWithChildProcess<ChildProcessByStdio<null, null, null>>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): PromiseWithChildProcess<ChildProcess>
-
-/**
- * @description wait for the command to exit
- * @returns a promise that resolves with the child process when the command exits successfully. Also, the child process is attached to the promise as a property.
- */
-export function spawnAsync(command: string, args?: any, options?: any): Promise<any> {
-    let child: any
-    const promise = new Promise<any>((resolve, reject) => {
-        if (Array.isArray(args)) options = { ...defaultOptions, ...options }
-        else args = { ...defaultOptions, ...args }
-        child = spawn(command, args, options)
-        child.on("exit", (code: number) => {
-            if (code === 0) return resolve(child)
-            if (Array.isArray(args)) {
-                const args2 = args.map((item: string) => item.trim()).filter(Boolean)
-                if (args2.length > 0) command = `${command} ${args2.join(" ")}`
-            }
-            reject(new Error(`spawn "${command}" failed with code ${code}`))
-            return
-        })
-    }) as PromiseWithChildProcess<any>
-    promise.child = child
-    return promise
-}
+import {
+    ChildProcess,
+    ChildProcessByStdio,
+    ChildProcessWithoutNullStreams,
+    SpawnOptions,
+    SpawnOptionsWithStdioTuple,
+    SpawnOptionsWithoutStdio,
+    StdioNull,
+    StdioPipe,
+    spawn,
+} from "child_process"
+import { Readable, Writable } from "stream"
+
+export interface PromiseWithChildProcess<T> extends Promise<T> {
+    child: T
+}
+
+export type Options =
+    | SpawnOptionsWithoutStdio
+    | SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>
+    | SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>
+    | SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>
+    | SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>
+    | SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>
+    | SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>
+    | SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>
+    | SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>
+    | SpawnOptions
+
+let defaultOptions: Options = {}
+
+/**
+ * @description get default options for spawnAsync
+ * @returns {Options} options
+ */
+export function getDefaultOptions(): Options {
+    return defaultOptions
+}
+
+/**
+ * @description set default options for spawnAsync
+ * @param  {Options | ((prev: Options) => Options)} options
+ */
+export function setDefaultOptions(options: Options | ((prev: Options) => Options)) {
+    if (typeof options === "function") {
+        defaultOptions = options(defaultOptions)
+        return
+    }
+    defaultOptions = options
+    return defaultOptions
+}
+
+export function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): PromiseWithChildProcess<ChildProcessWithoutNullStreams>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, Readable>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, null>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, Readable>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, Readable>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, null>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, null>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, null, Readable>>
+export function spawnAsync(
+    command: string,
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, null, null>>
+export function spawnAsync(command: string, options: SpawnOptions): PromiseWithChildProcess<ChildProcess>
+export function spawnAsync(
+    command: string,
+    args?: readonly string[],
+    options?: SpawnOptionsWithoutStdio,
+): PromiseWithChildProcess<ChildProcessWithoutNullStreams>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, Readable>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, Readable, null>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, Readable>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, Readable>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<Writable, null, null>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, Readable, null>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, null, Readable>>
+export function spawnAsync(
+    command: string,
+    args: readonly string[],
+    options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>,
+): PromiseWithChildProcess<ChildProcessByStdio<null, null, null>>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): PromiseWithChildProcess<ChildProcess>
+
+/**
+ * @description wait for the command to exit
+ * @returns a promise that resolves with the child process when the command exits successfully. Also, the child process is attached to the promise as a property.
+ */
+export function spawnAsync(command: string, args?: any, options?: any): Promise<any> {
+    let child: any
+    const promise = new Promise<any>((resolve, reject) => {
+        if (Array.isArray(args)) options = { ...defaultOptions, ...options }
+        else args = { ...defaultOptions, ...args }
+        child = spawn(command, args, options)
+        child.on("exit", (code: number) => {
+            if (code === 0) return resolve(child)
+            if (Array.isArray(args)) {
+                const args2 = args.map((item: string) => item.trim()).filter(Boolean)
+                if (args2.length > 0) command = `${command} ${args2.join(" ")}`
+            }
+            reject(new Error(`spawn "${command}" failed with code ${code}`))
+            return
+        })
+    }) as PromiseWithChildProcess<any>
+    promise.child = child
+    return promise
+}

package/src/utils/unzip.ts

@@ -1,34 +1,34 @@
-import which from "which"
-
-import { execAsync } from "./execAsync"
-
-export type UnzipOptions = {
-    /**
-     * 要解压的文件
-     */
-    input: string
-    /**
-     * 解压到的目标文件夹位置
-     */
-    output: string
-    /**
-     * 压缩文件时的工作目录
-     */
-    cwd?: string
-}
-
-/**
- * 使用 7z 命令解压文件
- * - 如果没有安装 7z，请先安装 7z 后再执行
- * - 下载地址：https://www.7-zip.org/download.html
- * - 如果已经安装，请按照以下步骤将 7z 添加到环境变量中
- * 1. 设置 → 系统 → 右侧系统信息 → 高级系统设置 → 环境变量
- * 2. 在系统变量中找到并选中 Path，点击编辑
- * 3. 点击新建，输入 7z 的安装路径（默认是 C:\Program Files\7-Zip），点击确定
- * 4. 重启终端，输入 7z，如果出现 7z 的版本信息，则安装成功
- * 5. 如果没有出现版本信息，请重启电脑，或者检查 7z 的安装路径是否正确
- */
-export async function unzip({ input, output, cwd }: UnzipOptions) {
-    await which("7z")
-    return await execAsync(`7z x ${input} -o${output}`, { cwd })
-}
+import which from "which"
+
+import { execAsync } from "./execAsync"
+
+export type UnzipOptions = {
+    /**
+     * 要解压的文件
+     */
+    input: string
+    /**
+     * 解压到的目标文件夹位置
+     */
+    output: string
+    /**
+     * 压缩文件时的工作目录
+     */
+    cwd?: string
+}
+
+/**
+ * 使用 7z 命令解压文件
+ * - 如果没有安装 7z，请先安装 7z 后再执行
+ * - 下载地址：https://www.7-zip.org/download.html
+ * - 如果已经安装，请按照以下步骤将 7z 添加到环境变量中
+ * 1. 设置 → 系统 → 右侧系统信息 → 高级系统设置 → 环境变量
+ * 2. 在系统变量中找到并选中 Path，点击编辑
+ * 3. 点击新建，输入 7z 的安装路径（默认是 C:\Program Files\7-Zip），点击确定
+ * 4. 重启终端，输入 7z，如果出现 7z 的版本信息，则安装成功
+ * 5. 如果没有出现版本信息，请重启电脑，或者检查 7z 的安装路径是否正确
+ */
+export async function unzip({ input, output, cwd }: UnzipOptions) {
+    await which("7z")
+    return await execAsync(`7z x ${input} -o${output}`, { cwd })
+}

package/src/utils/zip.ts

@@ -1,52 +1,52 @@
-import { cpus } from "os"
-import which from "which"
-
-import { execAsync } from "./execAsync"
-
-export type ZipOptions = {
-    /**
-     * 要压缩的文件
-     */
-    input: string | string[]
-    /**
-     * 压缩到的目标位置，文件名的后缀就是压缩格式，例如：.zip、.7z
-     */
-    output: string
-    /**
-     * 线程数
-     */
-    thread?: number | "auto" | "max"
-    /**
-     * 压缩等级，0-9
-     */
-    level?: number
-    /**
-     * 是否加密
-     */
-    password?: string
-    /**
-     * 压缩文件时的工作目录
-     */
-    cwd?: string
-}
-
-/**
- * 使用 7z 命令压缩文件
- * - 如果没有安装 7z，请先安装 7z 后再执行
- * - 下载地址：https://www.7-zip.org/download.html
- * - 如果已经安装，请按照以下步骤将 7z 添加到环境变量中
- * 1. 设置 → 系统 → 右侧系统信息 → 高级系统设置 → 环境变量
- * 2. 在系统变量中找到并选中 Path，点击编辑
- * 3. 点击新建，输入 7z 的安装路径（默认是 C:\Program Files\7-Zip），点击确定
- * 4. 重启终端，输入 7z，如果出现 7z 的版本信息，则安装成功
- * 5. 如果没有出现版本信息，请重启电脑，或者检查 7z 的安装路径是否正确
- */
-export async function zip({ input, output, thread = "auto", level, password, cwd }: ZipOptions) {
-    await which("7z")
-    input = Array.isArray(input) ? input.join(" ") : input
-    if (thread === "max") thread = cpus().length
-    return await execAsync(
-        `7z a ${output} ${input} -mmt=${thread === "auto" ? "on" : thread}${typeof level === "number" ? ` -mx=${level}` : ""}${password ? ` -p${password}` : ""}`,
-        { cwd },
-    )
-}
+import { cpus } from "os"
+import which from "which"
+
+import { execAsync } from "./execAsync"
+
+export type ZipOptions = {
+    /**
+     * 要压缩的文件
+     */
+    input: string | string[]
+    /**
+     * 压缩到的目标位置，文件名的后缀就是压缩格式，例如：.zip、.7z
+     */
+    output: string
+    /**
+     * 线程数
+     */
+    thread?: number | "auto" | "max"
+    /**
+     * 压缩等级，0-9
+     */
+    level?: number
+    /**
+     * 是否加密
+     */
+    password?: string
+    /**
+     * 压缩文件时的工作目录
+     */
+    cwd?: string
+}
+
+/**
+ * 使用 7z 命令压缩文件
+ * - 如果没有安装 7z，请先安装 7z 后再执行
+ * - 下载地址：https://www.7-zip.org/download.html
+ * - 如果已经安装，请按照以下步骤将 7z 添加到环境变量中
+ * 1. 设置 → 系统 → 右侧系统信息 → 高级系统设置 → 环境变量
+ * 2. 在系统变量中找到并选中 Path，点击编辑
+ * 3. 点击新建，输入 7z 的安装路径（默认是 C:\Program Files\7-Zip），点击确定
+ * 4. 重启终端，输入 7z，如果出现 7z 的版本信息，则安装成功
+ * 5. 如果没有出现版本信息，请重启电脑，或者检查 7z 的安装路径是否正确
+ */
+export async function zip({ input, output, thread = "auto", level, password, cwd }: ZipOptions) {
+    await which("7z")
+    input = Array.isArray(input) ? input.join(" ") : input
+    if (thread === "max") thread = cpus().length
+    return await execAsync(
+        `7z a ${output} ${input} -mmt=${thread === "auto" ? "on" : thread}${typeof level === "number" ? ` -mx=${level}` : ""}${password ? ` -p${password}` : ""}`,
+        { cwd },
+    )
+}

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-    "compilerOptions": {
-        "baseUrl": ".",
-        "strict": true,
-        "declaration": true,
-        "skipLibCheck": true,
-        "target": "ESNext",
-        "module": "ESNext",
-        "moduleResolution": "Bundler",
-        "paths": {
-            "@/*": ["src/*"]
-        }
-    },
-    "include": ["src"]
-}
+{
+    "compilerOptions": {
+        "baseUrl": ".",
+        "strict": true,
+        "declaration": true,
+        "skipLibCheck": true,
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "paths": {
+            "@/*": ["src/*"]
+        }
+    },
+    "include": ["src"]
+}