spawn-rx 5.1.1 → 6.0.0

package/test/{asserttest.ts → asserttest.test.ts}

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect } from "chai";
-import "./support";
+import { describe, expect, it } from "bun:test";
 
 function delay(ms: number) {
   return new Promise((resolve) => {
@@ -8,9 +7,9 @@ function delay(ms: number) {
   });
 }
 
-describe("The test runner", function () {
-  it("should pass this test", async function () {
+describe("The test runner", () => {
+  it("should pass this test", async () => {
     await delay(1000);
-    expect(true).to.be.ok;
+    expect(true).toBeTruthy();
   });
 });

package/test/{spawn.ts → spawn.test.ts}

@@ -1,57 +1,42 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-expressions */
-import { expect } from "chai";
-import "./support";
-
-import { spawn, spawnPromise, spawnDetachedPromise } from "../src/index";
-
+import { describe, expect, it } from "bun:test";
 import type { Observable } from "rxjs";
 import { of } from "rxjs";
+import { spawn, spawnPromise } from "../src/index";
 
-const uuidRegex =
-  /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 
-describe("The spawnPromise method", function () {
-  it("should return a uuid when we call uuid", async function () {
+describe("The spawnPromise method", () => {
+  it("should return a uuid when we call uuid", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", []);
-    expect(result.match(uuidRegex)).to.be.ok;
+    expect(result.match(uuidRegex)).toBeTruthy();
   });
 
-  it("should split stdout and stderr when we call uuid", async function () {
+  it("should split stdout and stderr when we call uuid", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", [], { split: true });
-    expect(result[0].match(uuidRegex)).to.be.ok;
-    expect(result[1].match(uuidRegex)).to.not.be.ok;
+    expect(result[0].match(uuidRegex)).toBeTruthy();
+    expect(result[1].match(uuidRegex)).toBeFalsy();
   });
 
-  it("should retur nthe exit code", async function () {
+  it("should retur nthe exit code", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     try {
       await spawnPromise("false", [], { split: true });
-      expect(false).to.be.true;
-    } catch (e) {
-      expect(e.code).to.be.equal(1);
+      expect(false).toBe(true);
+    } catch (e: any) {
+      expect(e.code).toBe(1);
     }
   });
 
-  it("should not stdout and stderr when we call uuid with split false", async function () {
+  it("should not stdout and stderr when we call uuid with split false", async () => {
     // NB: Since we get run via npm run test, we know that npm bins are in our
     // PATH.
     const result = await spawnPromise("uuid", [], { split: false });
-    expect(result.match(uuidRegex)).to.be.ok;
-  });
-});
-
-describe("The spawnDetachedPromise method", function () {
-  it("should return a uuid when we call uuid", async function () {
-    // NB: Since we get run via npm run test, we know that npm bins are in our
-    // PATH.
-    const result = await spawnDetachedPromise("uuid", ["--help"]);
-    expect(result.length > 10).to.be.ok;
+    expect(result.match(uuidRegex)).toBeTruthy();
   });
 });
 
@@ -85,81 +70,68 @@ function wrapSplitObservableInPromise(
   });
 }
 
-describe("The spawn method", function () {
-  it("should return a disposable subscription", async function () {
+describe("The spawn method", () => {
+  it("should return a disposable subscription", async () => {
     // this only check the unsubscribe goes w/o error, not that the spawned process is killed
     // (difficult to do that, maybe iterate through child processes and check ?)
     spawn("sleep", ["2"]).subscribe().unsubscribe();
   });
 
-  it("should return split stderr in a inner tag when called with split", async function () {
+  it("should return split stderr in a inner tag when called with split", async () => {
     // provide an invalid param to uuid so it complains on stderr
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "uuid",
-      ["foo"],
-      { split: true },
-    ) as any;
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", ["foo"], { split: true }) as any;
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stderr.length > 10).to.be.ok;
-    expect(result.stdout).to.be.empty;
-    expect(result.error).to.be.an("error");
+    expect(result.stderr.length > 10).toBeTruthy();
+    expect(result.stdout).toBe("");
+    expect(result.error).toBeInstanceOf(Error);
   });
 
-  it("should return split stdout in a inner tag when called with split", async function () {
+  it("should return split stdout in a inner tag when called with split", async () => {
     const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", [], {
       split: true,
     });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout.match(uuidRegex)).to.be.ok;
-    expect(result.stderr).to.be.empty;
-    expect(result.error).to.be.undefined;
+    expect(result.stdout.match(uuidRegex)).toBeTruthy();
+    expect(result.stderr).toBe("");
+    expect(result.error).toBeUndefined();
   });
 
-  it("should ignore stderr if options.stdio = ignore", async function () {
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "uuid",
-      ["foo"],
-      { split: true, stdio: [null, null, "ignore"] },
-    );
+  it("should ignore stderr if options.stdio = ignore", async () => {
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", ["foo"], {
+      split: true,
+      stdio: [null, null, "ignore"],
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stderr).to.be.empty;
+    expect(result.stderr).toBe("");
   });
 
-  it("should ignore stdout if options.stdio = inherit", async function () {
+  it("should ignore stdout if options.stdio = inherit", async () => {
     const rxSpawn: Observable<{ source: any; text: any }> = spawn("uuid", [], {
       split: true,
       stdio: [null, "inherit", null],
     });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout).to.be.empty;
+    expect(result.stdout).toBe("");
   });
 
-  it("should croak if stdin is provided but stdio.stdin is disabled", async function () {
+  it("should croak if stdin is provided but stdio.stdin is disabled", async () => {
     const stdin = of("a");
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "marked",
-      [],
-      {
-        split: true,
-        stdin: stdin,
-        stdio: ["ignore", null, null],
-      },
-    );
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("marked", [], {
+      split: true,
+      stdin: stdin,
+      stdio: ["ignore", null, null],
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.error).to.be.an("error");
+    expect(result.error).toBeInstanceOf(Error);
   });
 
-  it("should subscribe to provided stdin", async function () {
+  it("should subscribe to provided stdin", async () => {
     const stdin = of("a");
-    const rxSpawn: Observable<{ source: any; text: any }> = spawn(
-      "marked",
-      [],
-      {
-        split: true,
-        stdin: stdin,
-      },
-    );
+    const rxSpawn: Observable<{ source: any; text: any }> = spawn("marked", [], {
+      split: true,
+      stdin: stdin,
+    });
     const result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout.trim()).to.be.equal("<p>a</p>");
+    expect(result.stdout.trim()).toBe("<p>a</p>");
   });
 });

package/tsconfig.json

@@ -21,5 +21,5 @@
     "indentSize": 2,
     "tabSize": 2
   },
-  "exclude": ["node_modules", "lib"]
+  "exclude": ["node_modules", "lib", "test"]
 }

package/eslint.config.mjs

@@ -1,88 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import prettier from "eslint-plugin-prettier";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all,
-});
-
-export default [
-  ...compat.extends(
-    "eslint:recommended",
-    "prettier",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-  ),
-  {
-    files: ["./src/*.{ts,tsx}", "./test/*.{ts,tsx}"],
-    plugins: {
-      "@typescript-eslint": typescriptEslint,
-      prettier,
-    },
-
-    languageOptions: {
-      globals: {},
-      parser: tsParser,
-      ecmaVersion: 5,
-      sourceType: "script",
-
-      parserOptions: {
-        project: "./tsconfig.json",
-      },
-    },
-
-    rules: {
-      "prettier/prettier": "warn",
-
-      "spaced-comment": [
-        "error",
-        "always",
-        {
-          markers: ["/"],
-        },
-      ],
-
-      "no-fallthrough": "error",
-      "@typescript-eslint/ban-ts-comment": "warn",
-
-      "@typescript-eslint/consistent-type-imports": [
-        "error",
-        {
-          prefer: "type-imports",
-        },
-      ],
-
-      "@typescript-eslint/no-inferrable-types": [
-        "error",
-        {
-          ignoreParameters: false,
-          ignoreProperties: false,
-        },
-      ],
-
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "@typescript-eslint/no-floating-promises": "error",
-
-      "@typescript-eslint/no-unused-vars": [
-        "warn",
-        {
-          args: "after-used",
-          argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-          ignoreRestSiblings: true,
-        },
-      ],
-
-      "@typescript-eslint/no-empty-function": ["error"],
-      "@typescript-eslint/restrict-template-expressions": "off",
-    },
-  },
-];

package/lib/src/index.js

@@ -1,384 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findActualExecutable = findActualExecutable;
-exports.spawnDetached = spawnDetached;
-exports.spawn = spawn;
-exports.spawnDetachedPromise = spawnDetachedPromise;
-exports.spawnPromise = spawnPromise;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-var path = require("path");
-var net = require("net");
-var sfs = require("fs");
-var rxjs_1 = require("rxjs");
-var operators_1 = require("rxjs/operators");
-var child_process_1 = require("child_process");
-var debug_1 = require("debug");
-var isWindows = process.platform === "win32";
-var d = (0, debug_1.default)("spawn-rx"); // tslint:disable-line:no-var-requires
-/**
- * stat a file but don't throw if it doesn't exist
- *
- * @param  {string} file The path to a file
- * @return {Stats}       The stats structure
- *
- * @private
- */
-function statSyncNoException(file) {
-    try {
-        return sfs.statSync(file);
-    }
-    catch (_a) {
-        return null;
-    }
-}
-/**
- * Search PATH to see if a file exists in any of the path folders.
- *
- * @param  {string} exe The file to search for
- * @return {string}     A fully qualified path, or the original path if nothing
- *                      is found
- *
- * @private
- */
-function runDownPath(exe) {
-    // NB: Windows won't search PATH looking for executables in spawn like
-    // Posix does
-    // Files with any directory path don't get this applied
-    if (exe.match(/[\\/]/)) {
-        d("Path has slash in directory, bailing");
-        return exe;
-    }
-    var target = path.join(".", exe);
-    if (statSyncNoException(target)) {
-        d("Found executable in currect directory: ".concat(target));
-        return sfs.realpathSync(target);
-    }
-    var haystack = process.env.PATH.split(isWindows ? ";" : ":");
-    for (var _i = 0, haystack_1 = haystack; _i < haystack_1.length; _i++) {
-        var p = haystack_1[_i];
-        var needle = path.join(p, exe);
-        if (statSyncNoException(needle)) {
-            return sfs.realpathSync(needle);
-        }
-    }
-    d("Failed to find executable anywhere in path");
-    return exe;
-}
-/**
- * Finds the actual executable and parameters to run on Windows. This method
- * mimics the POSIX behavior of being able to run scripts as executables by
- * replacing the passed-in executable with the script runner, for PowerShell,
- * CMD, and node scripts.
- *
- * This method also does the work of running down PATH, which spawn on Windows
- * also doesn't do, unlike on POSIX.
- *
- * @param  {string} exe           The executable to run
- * @param  {string[]} args   The arguments to run
- *
- * @return {Object}               The cmd and args to run
- * @property {string} cmd         The command to pass to spawn
- * @property {string[]} args The arguments to pass to spawn
- */
-function findActualExecutable(exe, args) {
-    // POSIX can just execute scripts directly, no need for silly goosery
-    if (process.platform !== "win32") {
-        return { cmd: runDownPath(exe), args: args };
-    }
-    if (!sfs.existsSync(exe)) {
-        // NB: When you write something like `surf-client ... -- surf-build` on Windows,
-        // a shell would normally convert that to surf-build.cmd, but since it's passed
-        // in as an argument, it doesn't happen
-        var possibleExts = [".exe", ".bat", ".cmd", ".ps1"];
-        for (var _i = 0, possibleExts_1 = possibleExts; _i < possibleExts_1.length; _i++) {
-            var ext = possibleExts_1[_i];
-            var possibleFullPath = runDownPath("".concat(exe).concat(ext));
-            if (sfs.existsSync(possibleFullPath)) {
-                return findActualExecutable(possibleFullPath, args);
-            }
-        }
-    }
-    if (exe.match(/\.ps1$/i)) {
-        var cmd = path.join(process.env.SYSTEMROOT, "System32", "WindowsPowerShell", "v1.0", "PowerShell.exe");
-        var psargs = [
-            "-ExecutionPolicy",
-            "Unrestricted",
-            "-NoLogo",
-            "-NonInteractive",
-            "-File",
-            exe,
-        ];
-        return { cmd: cmd, args: psargs.concat(args) };
-    }
-    if (exe.match(/\.(bat|cmd)$/i)) {
-        var cmd = path.join(process.env.SYSTEMROOT, "System32", "cmd.exe");
-        var cmdArgs = __spreadArray(["/C", exe], args, true);
-        return { cmd: cmd, args: cmdArgs };
-    }
-    if (exe.match(/\.(js)$/i)) {
-        var cmd = process.execPath;
-        var nodeArgs = [exe];
-        return { cmd: cmd, args: nodeArgs.concat(args) };
-    }
-    // Dunno lol
-    return { cmd: exe, args: args };
-}
-/**
- * Spawns a process but detached from the current process. The process is put
- * into its own Process Group that can be killed by unsubscribing from the
- * return Observable.
- *
- * @param  {string} exe               The executable to run
- * @param  {string[]} params     The parameters to pass to the child
- * @param  {SpawnOptions & SpawnRxExtras} opts              Options to pass to spawn.
- *
- * @return {Observable<string>}       Returns an Observable that when subscribed
- *                                    to, will create a detached process. The
- *                                    process output will be streamed to this
- *                                    Observable, and if unsubscribed from, the
- *                                    process will be terminated early. If the
- *                                    process terminates with a non-zero value,
- *                                    the Observable will terminate with onError.
- */
-function spawnDetached(exe, params, opts) {
-    var _a = findActualExecutable(exe, params !== null && params !== void 0 ? params : []), cmd = _a.cmd, args = _a.args;
-    if (!isWindows) {
-        return spawn(cmd, args, Object.assign({}, opts || {}, { detached: true }));
-    }
-    var newParams = [cmd].concat(args);
-    var target = path.join(__dirname, "..", "..", "vendor", "jobber", "Jobber.exe");
-    var options = __assign(__assign({}, (opts !== null && opts !== void 0 ? opts : {})), { detached: true, jobber: true });
-    d("spawnDetached: ".concat(target, ", ").concat(newParams));
-    return spawn(target, newParams, options);
-}
-/**
- * Spawns a process attached as a child of the current process.
- *
- * @param  {string} exe               The executable to run
- * @param  {string[]} params     The parameters to pass to the child
- * @param  {SpawnOptions & SpawnRxExtras} opts              Options to pass to spawn.
- *
- * @return {Observable<string>}       Returns an Observable that when subscribed
- *                                    to, will create a child process. The
- *                                    process output will be streamed to this
- *                                    Observable, and if unsubscribed from, the
- *                                    process will be terminated early. If the
- *                                    process terminates with a non-zero value,
- *                                    the Observable will terminate with onError.
- */
-function spawn(exe, params, opts) {
-    opts = opts !== null && opts !== void 0 ? opts : {};
-    var spawnObs = new rxjs_1.Observable(function (subj) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        var stdin = opts.stdin, jobber = opts.jobber, split = opts.split, encoding = opts.encoding, spawnOpts = __rest(opts, ["stdin", "jobber", "split", "encoding"]);
-        var _a = findActualExecutable(exe, params), cmd = _a.cmd, args = _a.args;
-        d("spawning process: ".concat(cmd, " ").concat(args.join(), ", ").concat(JSON.stringify(spawnOpts)));
-        var proc = (0, child_process_1.spawn)(cmd, args, spawnOpts);
-        var bufHandler = function (source) { return function (b) {
-            if (b.length < 1) {
-                return;
-            }
-            if (opts.echoOutput) {
-                (source === "stdout" ? process.stdout : process.stderr).write(b);
-            }
-            var chunk = "<< String sent back was too long >>";
-            try {
-                if (typeof b === "string") {
-                    chunk = b.toString();
-                }
-                else {
-                    chunk = b.toString(encoding || "utf8");
-                }
-            }
-            catch (_a) {
-                chunk = "<< Lost chunk of process output for ".concat(exe, " - length was ").concat(b.length, ">>");
-            }
-            subj.next({ source: source, text: chunk });
-        }; };
-        var ret = new rxjs_1.Subscription();
-        if (opts.stdin) {
-            if (proc.stdin) {
-                ret.add(opts.stdin.subscribe({
-                    next: function (x) { return proc.stdin.write(x); },
-                    error: subj.error.bind(subj),
-                    complete: function () { return proc.stdin.end(); },
-                }));
-            }
-            else {
-                subj.error(new Error("opts.stdio conflicts with provided spawn opts.stdin observable, 'pipe' is required"));
-            }
-        }
-        var stderrCompleted = null;
-        var stdoutCompleted = null;
-        var noClose = false;
-        if (proc.stdout) {
-            stdoutCompleted = new rxjs_1.AsyncSubject();
-            proc.stdout.on("data", bufHandler("stdout"));
-            proc.stdout.on("close", function () {
-                stdoutCompleted.next(true);
-                stdoutCompleted.complete();
-            });
-        }
-        else {
-            stdoutCompleted = (0, rxjs_1.of)(true);
-        }
-        if (proc.stderr) {
-            stderrCompleted = new rxjs_1.AsyncSubject();
-            proc.stderr.on("data", bufHandler("stderr"));
-            proc.stderr.on("close", function () {
-                stderrCompleted.next(true);
-                stderrCompleted.complete();
-            });
-        }
-        else {
-            stderrCompleted = (0, rxjs_1.of)(true);
-        }
-        proc.on("error", function (e) {
-            noClose = true;
-            subj.error(e);
-        });
-        proc.on("close", function (code) {
-            noClose = true;
-            var pipesClosed = (0, rxjs_1.merge)(stdoutCompleted, stderrCompleted).pipe((0, operators_1.reduce)(function (acc) { return acc; }, true));
-            if (code === 0) {
-                pipesClosed.subscribe(function () { return subj.complete(); });
-            }
-            else {
-                pipesClosed.subscribe(function () {
-                    var e = new Error("Failed with exit code: ".concat(code));
-                    e.exitCode = code;
-                    e.code = code;
-                    subj.error(e);
-                });
-            }
-        });
-        ret.add(new rxjs_1.Subscription(function () {
-            if (noClose) {
-                return;
-            }
-            d("Killing process: ".concat(cmd, " ").concat(args.join()));
-            if (opts.jobber) {
-                // NB: Connecting to Jobber's named pipe will kill it
-                net.connect("\\\\.\\pipe\\jobber-".concat(proc.pid));
-                setTimeout(function () { return proc.kill(); }, 5 * 1000);
-            }
-            else {
-                proc.kill();
-            }
-        }));
-        return ret;
-    });
-    return opts.split ? spawnObs : spawnObs.pipe((0, operators_1.map)(function (x) { return x === null || x === void 0 ? void 0 : x.text; }));
-}
-function wrapObservableInPromise(obs) {
-    return new Promise(function (res, rej) {
-        var out = "";
-        obs.subscribe({
-            next: function (x) { return (out += x); },
-            error: function (e) {
-                var err = new Error("".concat(out, "\n").concat(e.message));
-                if ("exitCode" in e) {
-                    err.exitCode = e.exitCode;
-                    err.code = e.exitCode;
-                }
-                rej(err);
-            },
-            complete: function () { return res(out); },
-        });
-    });
-}
-function wrapObservableInSplitPromise(obs) {
-    return new Promise(function (res, rej) {
-        var out = "";
-        var err = "";
-        obs.subscribe({
-            next: function (x) { return (x.source === "stdout" ? (out += x.text) : (err += x.text)); },
-            error: function (e) {
-                var error = new Error("".concat(out, "\n").concat(e.message));
-                if ("exitCode" in e) {
-                    error.exitCode = e.exitCode;
-                    error.code = e.exitCode;
-                    error.stdout = out;
-                    error.stderr = err;
-                }
-                rej(error);
-            },
-            complete: function () { return res([out, err]); },
-        });
-    });
-}
-/**
- * Spawns a process but detached from the current process. The process is put
- * into its own Process Group.
- *
- * @param  {string} exe               The executable to run
- * @param  {string[]} params     The parameters to pass to the child
- * @param  {Object} opts              Options to pass to spawn.
- *
- * @return {Promise<string>}       Returns an Promise that represents a detached
- *                                 process. The value returned is the process
- *                                 output. If the process terminates with a
- *                                 non-zero value, the Promise will resolve with
- *                                 an Error.
- */
-function spawnDetachedPromise(exe, params, opts) {
-    if (opts === null || opts === void 0 ? void 0 : opts.split) {
-        return wrapObservableInSplitPromise(spawnDetached(exe, params, __assign(__assign({}, (opts !== null && opts !== void 0 ? opts : {})), { split: true })));
-    }
-    else {
-        return wrapObservableInPromise(spawnDetached(exe, params, __assign(__assign({}, (opts !== null && opts !== void 0 ? opts : {})), { split: false })));
-    }
-}
-/**
- * Spawns a process as a child process.
- *
- * @param  {string} exe               The executable to run
- * @param  {string[]} params     The parameters to pass to the child
- * @param  {Object} opts              Options to pass to spawn.
- *
- * @return {Promise<string>}       Returns an Promise that represents a child
- *                                 process. The value returned is the process
- *                                 output. If the process terminates with a
- *                                 non-zero value, the Promise will resolve with
- *                                 an Error.
- */
-function spawnPromise(exe, params, opts) {
-    if (opts === null || opts === void 0 ? void 0 : opts.split) {
-        return wrapObservableInSplitPromise(spawn(exe, params, __assign(__assign({}, (opts !== null && opts !== void 0 ? opts : {})), { split: true })));
-    }
-    else {
-        return wrapObservableInPromise(spawn(exe, params, __assign(__assign({}, (opts !== null && opts !== void 0 ? opts : {})), { split: false })));
-    }
-}
-//# sourceMappingURL=index.js.map