soda-nodejs 0.0.1 → 0.0.3

package/README.md

@@ -1,12 +1,12 @@
 # soda-node
 
-[![NPM version](https://img.shields.io/npm/v/soda-node.svg?style=flat)](https://npmjs.org/package/soda-node)
-[![NPM downloads](http://img.shields.io/npm/dm/soda-node.svg?style=flat)](https://npmjs.org/package/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
-$ yarn install
+$ pnpm install
 ```
 
 ```bash

package/dist/cjs/index.d.ts

@@ -1,41 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ExecOptions, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process";
-import { ObjectEncodingOptions } from "fs";
-export declare function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptions): Promise<void>;
-export declare function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>;
-export type ExecResult<T> = {
-    stdout: T;
-    stderr: T;
-};
-export declare function execAsync(command: string): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: {
-    encoding: "buffer" | null;
-} & ExecOptions): Promise<ExecResult<Buffer>>;
-export declare function execAsync(command: string, options: {
-    encoding: BufferEncoding;
-} & ExecOptions): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: {
-    encoding: BufferEncoding;
-} & ExecOptions): Promise<ExecResult<string | Buffer>>;
-export declare function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>;
+export * from "./utils/execAsync";
+export * from "./utils/spawnAsync";

package/dist/cjs/index.js

@@ -2,10 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -14,42 +10,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
-__export(src_exports, {
-  execAsync: () => execAsync,
-  spawnAsync: () => spawnAsync
-});
 module.exports = __toCommonJS(src_exports);
-var import_child_process = require("child_process");
-async function spawnAsync(command, args, options) {
-  await new Promise((resolve, reject) => {
-    const child = (0, import_child_process.spawn)(command, args, options);
-    child.on("exit", (code) => {
-      if (code !== 0) {
-        reject(new Error(`Command failed with code ${code}`));
-        return;
-      }
-      resolve();
-    });
-  });
-}
-async function execAsync(command, options) {
-  return await new Promise((resolve, reject) => {
-    (0, import_child_process.exec)(command, options, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve({ stdout, stderr });
-    });
-  });
-}
+__reExport(src_exports, require("./utils/execAsync"), module.exports);
+__reExport(src_exports, require("./utils/spawnAsync"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  execAsync,
-  spawnAsync
+  ...require("./utils/execAsync"),
+  ...require("./utils/spawnAsync")
 });
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["import { exec, ExecOptions, spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from \"child_process\"\r\nimport { ObjectEncodingOptions } from \"fs\"\r\n\r\nexport function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptions): Promise<void>\r\nexport function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>\r\nexport async function spawnAsync(command: string, args?: any, options?: any) {\r\n    await new Promise<void>((resolve, reject) => {\r\n        const child = spawn(command, args, options)\r\n        child.on(\"exit\", code => {\r\n            if (code !== 0) {\r\n                reject(new Error(`Command failed with code ${code}`))\r\n                return\r\n            }\r\n            resolve()\r\n        })\r\n    })\r\n}\r\n\r\nexport type ExecResult<T> = {\r\n    stdout: T\r\n    stderr: T\r\n}\r\n\r\nexport async function execAsync(command: string): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: \"buffer\" | null } & ExecOptions): Promise<ExecResult<Buffer>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options?: any) {\r\n    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {\r\n        exec(command, options, (error, stdout, stderr) => {\r\n            if (error) {\r\n                reject(error)\r\n                return\r\n            }\r\n            resolve({ stdout, stderr })\r\n        })\r\n    })\r\n}\r\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAAmI;AAuBnI,eAAsB,WAAW,SAAiB,MAAY,SAAe;AACzE,QAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AACzC,UAAM,YAAQ,4BAAM,SAAS,MAAM,OAAO;AAC1C,UAAM,GAAG,QAAQ,UAAQ;AACrB,UAAI,SAAS,GAAG;AACZ,eAAO,IAAI,MAAM,4BAA4B,MAAM,CAAC;AACpD;AAAA,MACJ;AACA,cAAQ;AAAA,IACZ,CAAC;AAAA,EACL,CAAC;AACL;AAaA,eAAsB,UAAU,SAAiB,SAAe;AAC5D,SAAO,MAAM,IAAI,QAAqC,CAAC,SAAS,WAAW;AACvE,mCAAK,SAAS,SAAS,CAAC,OAAO,QAAQ,WAAW;AAC9C,UAAI,OAAO;AACP,eAAO,KAAK;AACZ;AAAA,MACJ;AACA,cAAQ,EAAE,QAAQ,OAAO,CAAC;AAAA,IAC9B,CAAC;AAAA,EACL,CAAC;AACL;",
+  "sourcesContent": ["export * from \"@utils/execAsync\"\nexport * from \"@utils/spawnAsync\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,wBAAc,8BAAd;AACA,wBAAc,+BADd;",
   "names": []
 }

package/dist/cjs/utils/execAsync.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecOptions } from "child_process";
+import { ObjectEncodingOptions } from "fs";
+export type ExecResult<T> = {
+    stdout: T;
+    stderr: T;
+};
+export declare function execAsync(command: string): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: {
+    encoding: "buffer" | null;
+} & ExecOptions): Promise<ExecResult<Buffer>>;
+export declare function execAsync(command: string, options: {
+    encoding: BufferEncoding;
+} & ExecOptions): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: {
+    encoding: BufferEncoding;
+} & ExecOptions): Promise<ExecResult<string | Buffer>>;
+export declare function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>;

package/dist/cjs/utils/execAsync.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/execAsync.ts
+var execAsync_exports = {};
+__export(execAsync_exports, {
+  execAsync: () => execAsync
+});
+module.exports = __toCommonJS(execAsync_exports);
+var import_child_process = require("child_process");
+async function execAsync(command, options) {
+  return await new Promise((resolve, reject) => {
+    (0, import_child_process.exec)(command, options, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  execAsync
+});
+//# sourceMappingURL=execAsync.js.map

package/dist/cjs/utils/execAsync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/execAsync.ts"],
+  "sourcesContent": ["import { exec, ExecOptions } from \"child_process\"\r\nimport { ObjectEncodingOptions } from \"fs\"\r\n\r\nexport type ExecResult<T> = {\r\n    stdout: T\r\n    stderr: T\r\n}\r\n\r\nexport async function execAsync(command: string): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: \"buffer\" | null } & ExecOptions): Promise<ExecResult<Buffer>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options?: any) {\r\n    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {\r\n        exec(command, options, (error, stdout, stderr) => {\r\n            if (error) {\r\n                reject(error)\r\n                return\r\n            }\r\n            resolve({ stdout, stderr })\r\n        })\r\n    })\r\n}\r\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAAkC;AAclC,eAAsB,UAAU,SAAiB,SAAe;AAC5D,SAAO,MAAM,IAAI,QAAqC,CAAC,SAAS,WAAW;AACvE,mCAAK,SAAS,SAAS,CAAC,OAAO,QAAQ,WAAW;AAC9C,UAAI,OAAO;AACP,eAAO,KAAK;AACZ;AAAA,MACJ;AACA,cAAQ,EAAE,QAAQ,OAAO,CAAC;AAAA,IAC9B,CAAC;AAAA,EACL,CAAC;AACL;",
+  "names": []
+}

package/dist/cjs/utils/spawnAsync.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process";
+export declare function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptions): Promise<void>;
+export declare function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>;

package/dist/cjs/utils/spawnAsync.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/spawnAsync.ts
+var spawnAsync_exports = {};
+__export(spawnAsync_exports, {
+  spawnAsync: () => spawnAsync
+});
+module.exports = __toCommonJS(spawnAsync_exports);
+var import_child_process = require("child_process");
+async function spawnAsync(command, args, options) {
+  await new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, options);
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  spawnAsync
+});
+//# sourceMappingURL=spawnAsync.js.map

package/dist/cjs/utils/spawnAsync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/spawnAsync.ts"],
+  "sourcesContent": ["import { spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from \"child_process\"\r\n\r\nexport function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptions): Promise<void>\r\nexport function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>\r\nexport async function spawnAsync(command: string, args?: any, options?: any) {\r\n    await new Promise<void>((resolve, reject) => {\r\n        const child = spawn(command, args, options)\r\n        child.on(\"exit\", code => {\r\n            if (code !== 0) {\r\n                reject(new Error(`Command failed with code ${code}`))\r\n                return\r\n            }\r\n            resolve()\r\n        })\r\n    })\r\n}\r\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAAgH;AAsBhH,eAAsB,WAAW,SAAiB,MAAY,SAAe;AACzE,QAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AACzC,UAAM,YAAQ,4BAAM,SAAS,MAAM,OAAO;AAC1C,UAAM,GAAG,QAAQ,UAAQ;AACrB,UAAI,SAAS,GAAG;AACZ,eAAO,IAAI,MAAM,4BAA4B,MAAM,CAAC;AACpD;AAAA,MACJ;AACA,cAAQ;AAAA,IACZ,CAAC;AAAA,EACL,CAAC;AACL;",
+  "names": []
+}

package/dist/esm/index.d.ts

@@ -1,41 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { ExecOptions, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process";
-import { ObjectEncodingOptions } from "fs";
-export declare function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, options: SpawnOptions): Promise<void>;
-export declare function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
-export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>;
-export type ExecResult<T> = {
-    stdout: T;
-    stderr: T;
-};
-export declare function execAsync(command: string): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: {
-    encoding: "buffer" | null;
-} & ExecOptions): Promise<ExecResult<Buffer>>;
-export declare function execAsync(command: string, options: {
-    encoding: BufferEncoding;
-} & ExecOptions): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: {
-    encoding: BufferEncoding;
-} & ExecOptions): Promise<ExecResult<string | Buffer>>;
-export declare function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>;
-export declare function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>;
+export * from "./utils/execAsync";
+export * from "./utils/spawnAsync";

package/dist/esm/index.js

@@ -1,28 +1,3 @@
-import { exec, spawn } from "child_process";
-export async function spawnAsync(command, args, options) {
-  await new Promise((resolve, reject) => {
-    const child = spawn(command, args, options);
-    child.on("exit", code => {
-      if (code !== 0) {
-        reject(new Error(`Command failed with code ${code}`));
-        return;
-      }
-      resolve();
-    });
-  });
-}
-export async function execAsync(command, options) {
-  return await new Promise((resolve, reject) => {
-    exec(command, options, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve({
-        stdout,
-        stderr
-      });
-    });
-  });
-}
+export * from "./utils/execAsync";
+export * from "./utils/spawnAsync";
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["exec","spawn","spawnAsync","command","args","options","Promise","resolve","reject","child","on","code","Error","execAsync","error","stdout","stderr"],"sources":["../../src/index.ts"],"sourcesContent":["import { exec, ExecOptions, spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from \"child_process\"\r\nimport { ObjectEncodingOptions } from \"fs\"\r\n\r\nexport function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptions): Promise<void>\r\nexport function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>\r\nexport async function spawnAsync(command: string, args?: any, options?: any) {\r\n    await new Promise<void>((resolve, reject) => {\r\n        const child = spawn(command, args, options)\r\n        child.on(\"exit\", code => {\r\n            if (code !== 0) {\r\n                reject(new Error(`Command failed with code ${code}`))\r\n                return\r\n            }\r\n            resolve()\r\n        })\r\n    })\r\n}\r\n\r\nexport type ExecResult<T> = {\r\n    stdout: T\r\n    stderr: T\r\n}\r\n\r\nexport async function execAsync(command: string): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: \"buffer\" | null } & ExecOptions): Promise<ExecResult<Buffer>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options?: any) {\r\n    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {\r\n        exec(command, options, (error, stdout, stderr) => {\r\n            if (error) {\r\n                reject(error)\r\n                return\r\n            }\r\n            resolve({ stdout, stderr })\r\n        })\r\n    })\r\n}\r\n"],"mappings":"AAAA,SAASA,IAAI,EAAeC,KAAK,QAAkG,eAAe;AAuBlJ,OAAO,eAAeC,UAAUA,CAACC,OAAe,EAAEC,IAAU,EAAEC,OAAa,EAAE;EACzE,MAAM,IAAIC,OAAO,CAAO,CAACC,OAAO,EAAEC,MAAM,KAAK;IACzC,MAAMC,KAAK,GAAGR,KAAK,CAACE,OAAO,EAAEC,IAAI,EAAEC,OAAO,CAAC;IAC3CI,KAAK,CAACC,EAAE,CAAC,MAAM,EAAEC,IAAI,IAAI;MACrB,IAAIA,IAAI,KAAK,CAAC,EAAE;QACZH,MAAM,CAAC,IAAII,KAAK,CAAE,4BAA2BD,IAAK,EAAC,CAAC,CAAC;QACrD;MACJ;MACAJ,OAAO,CAAC,CAAC;IACb,CAAC,CAAC;EACN,CAAC,CAAC;AACN;AAaA,OAAO,eAAeM,SAASA,CAACV,OAAe,EAAEE,OAAa,EAAE;EAC5D,OAAO,MAAM,IAAIC,OAAO,CAA8B,CAACC,OAAO,EAAEC,MAAM,KAAK;IACvER,IAAI,CAACG,OAAO,EAAEE,OAAO,EAAE,CAACS,KAAK,EAAEC,MAAM,EAAEC,MAAM,KAAK;MAC9C,IAAIF,KAAK,EAAE;QACPN,MAAM,CAACM,KAAK,CAAC;QACb;MACJ;MACAP,OAAO,CAAC;QAAEQ,MAAM;QAAEC;MAAO,CAAC,CAAC;IAC/B,CAAC,CAAC;EACN,CAAC,CAAC;AACN"}
+{"version":3,"names":[],"sources":["../../src/index.ts"],"sourcesContent":["export * from \"@utils/execAsync\"\nexport * from \"@utils/spawnAsync\"\n"],"mappings":"AAAA;AACA"}

package/dist/esm/utils/execAsync.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ExecOptions } from "child_process";
+import { ObjectEncodingOptions } from "fs";
+export type ExecResult<T> = {
+    stdout: T;
+    stderr: T;
+};
+export declare function execAsync(command: string): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: {
+    encoding: "buffer" | null;
+} & ExecOptions): Promise<ExecResult<Buffer>>;
+export declare function execAsync(command: string, options: {
+    encoding: BufferEncoding;
+} & ExecOptions): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: {
+    encoding: BufferEncoding;
+} & ExecOptions): Promise<ExecResult<string | Buffer>>;
+export declare function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>;
+export declare function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>;

package/dist/esm/utils/execAsync.js

@@ -0,0 +1,16 @@
+import { exec } from "child_process";
+export async function execAsync(command, options) {
+  return await new Promise((resolve, reject) => {
+    exec(command, options, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+//# sourceMappingURL=execAsync.js.map

package/dist/esm/utils/execAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exec","execAsync","command","options","Promise","resolve","reject","error","stdout","stderr"],"sources":["../../../src/utils/execAsync.ts"],"sourcesContent":["import { exec, ExecOptions } from \"child_process\"\r\nimport { ObjectEncodingOptions } from \"fs\"\r\n\r\nexport type ExecResult<T> = {\r\n    stdout: T\r\n    stderr: T\r\n}\r\n\r\nexport async function execAsync(command: string): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: \"buffer\" | null } & ExecOptions): Promise<ExecResult<Buffer>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>\r\nexport async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>\r\nexport async function execAsync(command: string, options?: any) {\r\n    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {\r\n        exec(command, options, (error, stdout, stderr) => {\r\n            if (error) {\r\n                reject(error)\r\n                return\r\n            }\r\n            resolve({ stdout, stderr })\r\n        })\r\n    })\r\n}\r\n"],"mappings":"AAAA,SAASA,IAAI,QAAqB,eAAe;AAcjD,OAAO,eAAeC,SAASA,CAACC,OAAe,EAAEC,OAAa,EAAE;EAC5D,OAAO,MAAM,IAAIC,OAAO,CAA8B,CAACC,OAAO,EAAEC,MAAM,KAAK;IACvEN,IAAI,CAACE,OAAO,EAAEC,OAAO,EAAE,CAACI,KAAK,EAAEC,MAAM,EAAEC,MAAM,KAAK;MAC9C,IAAIF,KAAK,EAAE;QACPD,MAAM,CAACC,KAAK,CAAC;QACb;MACJ;MACAF,OAAO,CAAC;QAAEG,MAAM;QAAEC;MAAO,CAAC,CAAC;IAC/B,CAAC,CAAC;EACN,CAAC,CAAC;AACN"}

package/dist/esm/utils/spawnAsync.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process";
+export declare function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, options: SpawnOptions): Promise<void>;
+export declare function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>;
+export declare function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>;

package/dist/esm/utils/spawnAsync.js

@@ -0,0 +1,14 @@
+import { spawn } from "child_process";
+export async function spawnAsync(command, args, options) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, options);
+    child.on("exit", code => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+//# sourceMappingURL=spawnAsync.js.map

package/dist/esm/utils/spawnAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["spawn","spawnAsync","command","args","options","Promise","resolve","reject","child","on","code","Error"],"sources":["../../../src/utils/spawnAsync.ts"],"sourcesContent":["import { spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from \"child_process\"\r\n\r\nexport function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, options: SpawnOptions): Promise<void>\r\nexport function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>\r\nexport function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>\r\nexport async function spawnAsync(command: string, args?: any, options?: any) {\r\n    await new Promise<void>((resolve, reject) => {\r\n        const child = spawn(command, args, options)\r\n        child.on(\"exit\", code => {\r\n            if (code !== 0) {\r\n                reject(new Error(`Command failed with code ${code}`))\r\n                return\r\n            }\r\n            resolve()\r\n        })\r\n    })\r\n}\r\n"],"mappings":"AAAA,SAASA,KAAK,QAAkG,eAAe;AAsB/H,OAAO,eAAeC,UAAUA,CAACC,OAAe,EAAEC,IAAU,EAAEC,OAAa,EAAE;EACzE,MAAM,IAAIC,OAAO,CAAO,CAACC,OAAO,EAAEC,MAAM,KAAK;IACzC,MAAMC,KAAK,GAAGR,KAAK,CAACE,OAAO,EAAEC,IAAI,EAAEC,OAAO,CAAC;IAC3CI,KAAK,CAACC,EAAE,CAAC,MAAM,EAAEC,IAAI,IAAI;MACrB,IAAIA,IAAI,KAAK,CAAC,EAAE;QACZH,MAAM,CAAC,IAAII,KAAK,CAAE,4BAA2BD,IAAK,EAAC,CAAC,CAAC;QACrD;MACJ;MACAJ,OAAO,CAAC,CAAC;IACb,CAAC,CAAC;EACN,CAAC,CAAC;AACN"}

package/package.json

@@ -1,34 +1,30 @@
 {
-    "name": "soda-nodejs",
-    "version": "0.0.1",
-    "description": "",
-    "main": "dist/cjs/index.js",
-    "module": "dist/esm/index.js",
-    "types": "dist/esm/index.d.ts",
-    "scripts": {
-        "dev": "father dev",
-        "build": "father build",
-        "build:deps": "father prebundle",
-        "prepublishOnly": "father doctor && npm run build"
-    },
-    "keywords": [],
-    "authors": [],
-    "license": "MIT",
-    "files": [
-        "compiled",
-        "dist",
-        "src"
-    ],
-    "publishConfig": {
-        "access": "public",
-        "registry": "https://registry.npmjs.org/"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/1adybug/soda-nodejs.git"
-    },
-    "devDependencies": {
-        "@types/node": "^20.11.30",
-        "father": "^4.4.0"
-    }
-}
+  "name": "soda-nodejs",
+  "version": "0.0.3",
+  "description": "",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "keywords": [],
+  "authors": [],
+  "license": "MIT",
+  "files": [
+    "compiled",
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": "https://github.com/1adybug/deepsea/tree/main/packages/soda-nodejs",
+  "devDependencies": {
+    "@types/node": "^20.14.10",
+    "father": "^4.5.0-rc.2"
+  },
+  "scripts": {
+    "dev": "father dev",
+    "build": "father build",
+    "build:deps": "father prebundle"
+  }
+}

package/src/index.ts

@@ -1,58 +1,2 @@
-import { exec, ExecOptions, spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process"
-import { ObjectEncodingOptions } from "fs"
-
-export function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>
-export function spawnAsync(command: string, options: SpawnOptions): Promise<void>
-export function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>
-export function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>
-export async function spawnAsync(command: string, args?: any, options?: any) {
-    await new Promise<void>((resolve, reject) => {
-        const child = spawn(command, args, options)
-        child.on("exit", code => {
-            if (code !== 0) {
-                reject(new Error(`Command failed with code ${code}`))
-                return
-            }
-            resolve()
-        })
-    })
-}
-
-export type ExecResult<T> = {
-    stdout: T
-    stderr: T
-}
-
-export async function execAsync(command: string): Promise<ExecResult<string>>
-export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions): Promise<ExecResult<Buffer>>
-export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>
-export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>
-export async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>
-export async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>
-export async function execAsync(command: string, options?: any) {
-    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {
-        exec(command, options, (error, stdout, stderr) => {
-            if (error) {
-                reject(error)
-                return
-            }
-            resolve({ stdout, stderr })
-        })
-    })
-}
+export * from "@utils/execAsync"
+export * from "@utils/spawnAsync"

package/src/utils/execAsync.ts

@@ -0,0 +1,25 @@
+import { exec, ExecOptions } from "child_process"
+import { ObjectEncodingOptions } from "fs"
+
+export type ExecResult<T> = {
+    stdout: T
+    stderr: T
+}
+
+export async function execAsync(command: string): Promise<ExecResult<string>>
+export async function execAsync(command: string, options: { encoding: "buffer" | null } & ExecOptions): Promise<ExecResult<Buffer>>
+export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string>>
+export async function execAsync(command: string, options: { encoding: BufferEncoding } & ExecOptions): Promise<ExecResult<string | Buffer>>
+export async function execAsync(command: string, options: ExecOptions): Promise<ExecResult<string>>
+export async function execAsync(command: string, options: (ObjectEncodingOptions & ExecOptions) | undefined | null): Promise<ExecResult<string | Buffer>>
+export async function execAsync(command: string, options?: any) {
+    return await new Promise<ExecResult<string | Buffer>>((resolve, reject) => {
+        exec(command, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(error)
+                return
+            }
+            resolve({ stdout, stderr })
+        })
+    })
+}

package/src/utils/spawnAsync.ts

@@ -0,0 +1,34 @@
+import { spawn, SpawnOptions, SpawnOptionsWithoutStdio, SpawnOptionsWithStdioTuple, StdioNull, StdioPipe } from "child_process"
+
+export function spawnAsync(command: string, options?: SpawnOptionsWithoutStdio): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>
+export function spawnAsync(command: string, options: SpawnOptions): Promise<void>
+export function spawnAsync(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): Promise<void>
+export function spawnAsync(command: string, args: readonly string[], options: SpawnOptions): Promise<void>
+export async function spawnAsync(command: string, args?: any, options?: any) {
+    await new Promise<void>((resolve, reject) => {
+        const child = spawn(command, args, options)
+        child.on("exit", code => {
+            if (code !== 0) {
+                reject(new Error(`Command failed with code ${code}`))
+                return
+            }
+            resolve()
+        })
+    })
+}