spawn-rx 3.0.0 → 4.0.0

package/src/index.ts

@@ -1,16 +1,18 @@
-import * as path from 'path';
-import * as net from 'net';
-import * as sfs from 'fs';
-import * as assign from 'lodash.assign';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as path from "path";
+import * as net from "net";
+import * as sfs from "fs";
+import * as assign from "lodash.assign";
 
-import { Observable, Observer, Subscription, AsyncSubject, Subject, of, merge } from 'rxjs';
-import { pluck, reduce } from 'rxjs/operators';
-import * as childProcess from 'child_process';
+import type { Observer, Subject } from "rxjs";
+import { Observable, Subscription, AsyncSubject, of, merge } from "rxjs";
+import { map, reduce } from "rxjs/operators";
+import { spawn as spawnOg } from "child_process";
+import Debug from "debug";
 
-const spawnOg: typeof childProcess.spawn = require('child_process').spawn; //tslint:disable-line:no-var-requires
-const isWindows = process.platform === 'win32';
+const isWindows = process.platform === "win32";
 
-const d = require('debug')('spawn-rx'); //tslint:disable-line:no-var-requires
+const d = Debug("spawn-rx"); // tslint:disable-line:no-var-requires
 
 /**
  * stat a file but don't throw if it doesn't exist
@@ -23,7 +25,7 @@ const d = require('debug')('spawn-rx'); //tslint:disable-line:no-var-requires
 function statSyncNoException(file: string): sfs.Stats | null {
   try {
     return sfs.statSync(file);
-  } catch (e) {
+  } catch {
     return null;
   }
 }
@@ -42,26 +44,26 @@ function runDownPath(exe: string): string {
   // Posix does
 
   // Files with any directory path don't get this applied
-  if (exe.match(/[\\\/]/)) {
-    d('Path has slash in directory, bailing');
+  if (exe.match(/[\\/]/)) {
+    d("Path has slash in directory, bailing");
     return exe;
   }
 
-  let target = path.join('.', exe);
+  const target = path.join(".", exe);
   if (statSyncNoException(target)) {
     d(`Found executable in currect directory: ${target}`);
     return target;
   }
 
-  let haystack = process.env.PATH!.split(isWindows ? ';' : ':');
-  for (let p of haystack) {
-    let needle = path.join(p, exe);
+  const haystack = process.env.PATH!.split(isWindows ? ";" : ":");
+  for (const p of haystack) {
+    const needle = path.join(p, exe);
     if (statSyncNoException(needle)) {
       return needle;
     }
   }
 
-  d('Failed to find executable anywhere in path');
+  d("Failed to find executable anywhere in path");
   return exe;
 }
 
@@ -81,12 +83,15 @@ function runDownPath(exe: string): string {
  * @property {string} cmd         The command to pass to spawn
  * @property {Array<string>} args The arguments to pass to spawn
  */
-export function findActualExecutable(exe: string, args: Array<string>): {
+export function findActualExecutable(
+  exe: string,
+  args: Array<string>,
+): {
   cmd: string;
-  args: Array<string>
+  args: Array<string>;
 } {
   // POSIX can just execute scripts directly, no need for silly goosery
-  if (process.platform !== 'win32') {
+  if (process.platform !== "win32") {
     return { cmd: runDownPath(exe), args: args };
   }
 
@@ -94,9 +99,9 @@ export function findActualExecutable(exe: string, args: Array<string>): {
     // 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
-    const possibleExts = ['.exe', '.bat', '.cmd', '.ps1'];
-    for (let ext of possibleExts) {
-      let possibleFullPath = runDownPath(`${exe}${ext}`);
+    const possibleExts = [".exe", ".bat", ".cmd", ".ps1"];
+    for (const ext of possibleExts) {
+      const possibleFullPath = runDownPath(`${exe}${ext}`);
 
       if (sfs.existsSync(possibleFullPath)) {
         return findActualExecutable(possibleFullPath, args);
@@ -105,22 +110,35 @@ export function findActualExecutable(exe: string, args: Array<string>): {
   }
 
   if (exe.match(/\.ps1$/i)) {
-    let cmd = path.join(process.env.SYSTEMROOT!, 'System32', 'WindowsPowerShell', 'v1.0', 'PowerShell.exe');
-    let psargs = ['-ExecutionPolicy', 'Unrestricted', '-NoLogo', '-NonInteractive', '-File', exe];
+    const cmd = path.join(
+      process.env.SYSTEMROOT!,
+      "System32",
+      "WindowsPowerShell",
+      "v1.0",
+      "PowerShell.exe",
+    );
+    const psargs = [
+      "-ExecutionPolicy",
+      "Unrestricted",
+      "-NoLogo",
+      "-NonInteractive",
+      "-File",
+      exe,
+    ];
 
     return { cmd: cmd, args: psargs.concat(args) };
   }
 
   if (exe.match(/\.(bat|cmd)$/i)) {
-    let cmd = path.join(process.env.SYSTEMROOT!, 'System32', 'cmd.exe');
-    let cmdArgs = ['/C', exe, ...args];
+    const cmd = path.join(process.env.SYSTEMROOT!, "System32", "cmd.exe");
+    const cmdArgs = ["/C", exe, ...args];
 
     return { cmd: cmd, args: cmdArgs };
   }
 
   if (exe.match(/\.(js)$/i)) {
-    let cmd = process.execPath;
-    let nodeArgs = [exe];
+    const cmd = process.execPath;
+    const nodeArgs = [exe];
 
     return { cmd: cmd, args: nodeArgs.concat(args) };
   }
@@ -146,7 +164,11 @@ export function findActualExecutable(exe: string, args: Array<string>): {
  *                                    process terminates with a non-zero value,
  *                                    the Observable will terminate with onError.
  */
-export function spawnDetached(exe: string, params: Array<string>, opts: any = null): Observable<string> {
+export function spawnDetached(
+  exe: string,
+  params: Array<string>,
+  opts: any = null,
+): Observable<string> {
   const { cmd, args } = findActualExecutable(exe, params);
 
   if (!isWindows) {
@@ -155,8 +177,15 @@ export function spawnDetached(exe: string, params: Array<string>, opts: any = nu
 
   const newParams = [cmd].concat(args);
 
-  let target = path.join(__dirname, '..', '..', 'vendor', 'jobber', 'Jobber.exe');
-  let options = assign({}, opts || {}, { detached: true, jobber: true });
+  const target = path.join(
+    __dirname,
+    "..",
+    "..",
+    "vendor",
+    "jobber",
+    "Jobber.exe",
+  );
+  const options = assign({}, opts || {}, { detached: true, jobber: true });
 
   d(`spawnDetached: ${target}, ${newParams}`);
   return spawn(target, newParams, options);
@@ -178,123 +207,157 @@ export function spawnDetached(exe: string, params: Array<string>, opts: any = nu
  *                                    the Observable will terminate with onError.
  */
 
-export function spawn<T = string>(exe: string, params: Array<string> = [], opts: any = null): Observable<T> {
+export function spawn<T = string>(
+  exe: string,
+  params: Array<string> = [],
+  opts: any = null,
+): Observable<T> {
   opts = opts || {};
-  let spawnObs = Observable.create((subj: Observer<{
-    source: any,
-    text: any
-    }>) => {
-    let { stdin, ...optsWithoutStdIn } = opts;
-    let { cmd, args } = findActualExecutable(exe, params);
-    d(`spawning process: ${cmd} ${args.join()}, ${JSON.stringify(optsWithoutStdIn)}`);
-    let origOpts = assign({}, optsWithoutStdIn);
-    if ('jobber' in origOpts) {
-      delete origOpts.jobber;
-    }
-    if ('split' in origOpts) {
-      delete origOpts.split;
-    }
-
-    const proc = spawnOg(cmd, args, origOpts);
-
-    let bufHandler = (source: string) => (b: string | Buffer) => {
-      if (b.length < 1) {
-        return;
+  const spawnObs = Observable.create(
+    (
+      subj: Observer<{
+        source: any;
+        text: any;
+      }>,
+    ) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { _, ...optsWithoutStdIn } = opts;
+      const { cmd, args } = findActualExecutable(exe, params);
+      d(
+        `spawning process: ${cmd} ${args.join()}, ${JSON.stringify(
+          optsWithoutStdIn,
+        )}`,
+      );
+      const origOpts = assign({}, optsWithoutStdIn);
+      if ("jobber" in origOpts) {
+        delete origOpts.jobber;
       }
-      let chunk = '<< String sent back was too long >>';
-      try {
-        if (typeof b === 'string') {
-          chunk = b.toString();
-        } else {
-          chunk = b.toString(origOpts.encoding || 'utf8');
-        }
-      } catch (e) {
-        chunk = `<< Lost chunk of process output for ${exe} - length was ${b.length}>>`;
+      if ("split" in origOpts) {
+        delete origOpts.split;
       }
 
-      subj.next({ source: source, text: chunk });
-    };
-
-    let ret = new Subscription();
-
-    if (opts.stdin) {
-      if (proc.stdin) {
-        ret.add(opts.stdin.subscribe(
-          (x: any) => proc.stdin.write(x),
-          subj.error.bind(subj),
-          () => proc.stdin.end()
-        ));
-      } else {
-        subj.error(new Error(`opts.stdio conflicts with provided spawn opts.stdin observable, 'pipe' is required`));
-      }
-    }
-
-    let stderrCompleted: Subject<boolean> | Observable<boolean> | null = null;
-    let stdoutCompleted: Subject<boolean> | Observable<boolean> | null = null;
-    let noClose = false;
-
-    if (proc.stdout) {
-      stdoutCompleted = new AsyncSubject<boolean>();
-      proc.stdout.on('data', bufHandler('stdout'));
-      proc.stdout.on('close', () => { (stdoutCompleted! as Subject<boolean>).next(true); (stdoutCompleted! as Subject<boolean>).complete(); });
-    } else {
-      stdoutCompleted = of(true);
-    }
+      const proc = spawnOg(cmd, args, origOpts);
 
-    if (proc.stderr) {
-      stderrCompleted = new AsyncSubject<boolean>();
-      proc.stderr.on('data', bufHandler('stderr'));
-      proc.stderr.on('close', () => { (stderrCompleted! as Subject<boolean>).next(true); (stderrCompleted! as Subject<boolean>).complete(); });
-    } else {
-      stderrCompleted = of(true);
-    }
+      const bufHandler = (source: string) => (b: string | Buffer) => {
+        if (b.length < 1) {
+          return;
+        }
+        let chunk = "<< String sent back was too long >>";
+        try {
+          if (typeof b === "string") {
+            chunk = b.toString();
+          } else {
+            chunk = b.toString(origOpts.encoding || "utf8");
+          }
+        } catch {
+          chunk = `<< Lost chunk of process output for ${exe} - length was ${b.length}>>`;
+        }
 
-    proc.on('error', (e: Error) => {
-      noClose = true;
-      subj.error(e);
-    });
+        subj.next({ source: source, text: chunk });
+      };
 
-    proc.on('close', (code: number) => {
-      noClose = true;
-      let pipesClosed = merge(stdoutCompleted!, stderrCompleted!)
-        .pipe(reduce((acc) => acc, true));
+      const ret = new Subscription();
 
-      if (code === 0) {
-        pipesClosed.subscribe(() => subj.complete());
-      } else {
-        pipesClosed.subscribe(() => subj.error(new Error(`Failed with exit code: ${code}`)));
+      if (opts.stdin) {
+        if (proc.stdin) {
+          ret.add(
+            opts.stdin.subscribe(
+              (x: any) => proc.stdin.write(x),
+              subj.error.bind(subj),
+              () => proc.stdin.end(),
+            ),
+          );
+        } else {
+          subj.error(
+            new Error(
+              `opts.stdio conflicts with provided spawn opts.stdin observable, 'pipe' is required`,
+            ),
+          );
+        }
       }
-    });
 
-    ret.add(new Subscription(() => {
-      if (noClose) {
-        return;
+      let stderrCompleted: Subject<boolean> | Observable<boolean> | null = null;
+      let stdoutCompleted: Subject<boolean> | Observable<boolean> | null = null;
+      let noClose = false;
+
+      if (proc.stdout) {
+        stdoutCompleted = new AsyncSubject<boolean>();
+        proc.stdout.on("data", bufHandler("stdout"));
+        proc.stdout.on("close", () => {
+          (stdoutCompleted! as Subject<boolean>).next(true);
+          (stdoutCompleted! as Subject<boolean>).complete();
+        });
+      } else {
+        stdoutCompleted = of(true);
       }
 
-      d(`Killing process: ${cmd} ${args.join()}`);
-      if (opts.jobber) {
-        // NB: Connecting to Jobber's named pipe will kill it
-        net.connect(`\\\\.\\pipe\\jobber-${proc.pid}`);
-        setTimeout(() => proc.kill(), 5 * 1000);
+      if (proc.stderr) {
+        stderrCompleted = new AsyncSubject<boolean>();
+        proc.stderr.on("data", bufHandler("stderr"));
+        proc.stderr.on("close", () => {
+          (stderrCompleted! as Subject<boolean>).next(true);
+          (stderrCompleted! as Subject<boolean>).complete();
+        });
       } else {
-        proc.kill();
+        stderrCompleted = of(true);
       }
-    }));
 
-    return ret;
-  });
+      proc.on("error", (e: Error) => {
+        noClose = true;
+        subj.error(e);
+      });
+
+      proc.on("close", (code: number) => {
+        noClose = true;
+        const pipesClosed = merge(stdoutCompleted!, stderrCompleted!).pipe(
+          reduce((acc) => acc, true),
+        );
 
-  return opts.split ? spawnObs : spawnObs.pipe(pluck('text'));
+        if (code === 0) {
+          pipesClosed.subscribe(() => subj.complete());
+        } else {
+          pipesClosed.subscribe(() => {
+            const e: any = new Error(`Failed with exit code: ${code}`);
+            e.exitCode = code;
+
+            subj.error(e);
+          });
+        }
+      });
+
+      ret.add(
+        new Subscription(() => {
+          if (noClose) {
+            return;
+          }
+
+          d(`Killing process: ${cmd} ${args.join()}`);
+          if (opts.jobber) {
+            // NB: Connecting to Jobber's named pipe will kill it
+            net.connect(`\\\\.\\pipe\\jobber-${proc.pid}`);
+            setTimeout(() => proc.kill(), 5 * 1000);
+          } else {
+            proc.kill();
+          }
+        }),
+      );
+
+      return ret;
+    },
+  );
+
+  return opts.split ? spawnObs : spawnObs.pipe(map((x: any) => x?.text));
 }
 
 function wrapObservableInPromise<T>(obs: Observable<T>) {
   return new Promise<string>((res, rej) => {
-    let out = '';
+    let out = "";
 
     obs.subscribe(
-      (x) => out += x,
+      (x) => (out += x),
       (e) => rej(new Error(`${out}\n${e.message}`)),
-      () => res(out));
+      () => res(out),
+    );
   });
 }
 
@@ -312,7 +375,11 @@ function wrapObservableInPromise<T>(obs: Observable<T>) {
  *                                 non-zero value, the Promise will resolve with
  *                                 an Error.
  */
-export function spawnDetachedPromise(exe: string, params: Array<string>, opts: any = null): Promise<string> {
+export function spawnDetachedPromise(
+  exe: string,
+  params: Array<string>,
+  opts: any = null,
+): Promise<string> {
   return wrapObservableInPromise<string>(spawnDetached(exe, params, opts));
 }
 
@@ -329,6 +396,10 @@ export function spawnDetachedPromise(exe: string, params: Array<string>, opts: a
  *                                 non-zero value, the Promise will resolve with
  *                                 an Error.
  */
-export function spawnPromise(exe: string, params: Array<string>, opts: any = null): Promise<string> {
+export function spawnPromise(
+  exe: string,
+  params: Array<string>,
+  opts: any = null,
+): Promise<string> {
   return wrapObservableInPromise<string>(spawn(exe, params, opts));
 }

package/test/asserttest.ts

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

package/test/spawn.ts

@@ -1,102 +1,139 @@
-import { expect } from 'chai';
-import './support';
+/* 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 { spawn, spawnPromise, spawnDetachedPromise } from "../src/index";
 
-import { Observable, of } from 'rxjs';
+import type { Observable } from "rxjs";
+import { of } from "rxjs";
 
-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", 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.
-    let result = await spawnPromise('uuid', []);
+    const result = await spawnPromise("uuid", []);
     expect(result.match(uuidRegex)).to.be.ok;
   });
 });
 
-describe('The spawnDetachedPromise method', function() {
-  it('should return a uuid when we call uuid', async function() {
+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.
-    let result = await spawnDetachedPromise('uuid', ['--help']);
+    const result = await spawnDetachedPromise("uuid", ["--help"]);
     expect(result.length > 10).to.be.ok;
   });
 });
 
-function wrapSplitObservableInPromise(obs: Observable<{
-  source: any,
-  text: any
-}>): Promise<{
-  stderr: string,
-  stdout: string,
-  error: Error | undefined
+function wrapSplitObservableInPromise(
+  obs: Observable<{
+    source: any;
+    text: any;
+  }>,
+): Promise<{
+  stderr: string;
+  stdout: string;
+  error: Error | undefined;
 }> {
   return new Promise((res) => {
-    let out = {stderr: '', stdout: '', error: undefined };
+    const out = { stderr: "", stdout: "", error: undefined };
 
     obs.subscribe(
       (x) => {
-        if (x.source === 'stdout') {
+        if (x.source === "stdout") {
           out.stdout += x.text;
         } else {
           out.stderr += x.text;
         }
       },
-      (e) => { out.error = e; res(out); },
-      () => res(out));
+      (e) => {
+        out.error = e;
+        res(out);
+      },
+      () => res(out),
+    );
   });
 }
 
-describe('The spawn method', function() {
-  it('should return a disposable subscription', async function() {
+describe("The spawn method", function () {
+  it("should return a disposable subscription", async function () {
     // 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();
+    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 function () {
     // provide an invalid param to uuid so it complains on stderr
-    let rxSpawn: Observable<{ source: any, text: any }> = spawn('uuid', ['foo'], {split: true}) as any;
-    let result = await wrapSplitObservableInPromise(rxSpawn);
+    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.error).to.be.an("error");
   });
 
-  it('should return split stdout in a inner tag when called with split', async function() {
-    let rxSpawn: Observable<{ source: any, text: any }> = spawn('uuid', [], {split: true});
-    let result = await wrapSplitObservableInPromise(rxSpawn);
+  it("should return split stdout in a inner tag when called with split", async function () {
+    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;
   });
 
-  it('should ignore stderr if options.stdio = ignore', async function() {
-    let rxSpawn: Observable<{ source: any, text: any }> = spawn('uuid', ['foo'], {split: true, stdio: [null, null, 'ignore']});
-    let result = await wrapSplitObservableInPromise(rxSpawn);
+  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"] },
+    );
+    const result = await wrapSplitObservableInPromise(rxSpawn);
     expect(result.stderr).to.be.empty;
   });
 
-  it('should ignore stdout if options.stdio = inherit', async function() {
-    let rxSpawn: Observable<{ source: any, text: any }> = spawn('uuid', [], {split: true, stdio: [null, 'inherit', null]});
-    let result = await wrapSplitObservableInPromise(rxSpawn);
+  it("should ignore stdout if options.stdio = inherit", async function () {
+    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;
   });
 
-  it('should croak if stdin is provided but stdio.stdin is disabled', async function() {
-    let stdin = of('a');
-    let rxSpawn: Observable<{ source: any, text: any }>  = spawn('marked', [], {split: true, stdin: stdin, stdio: ['ignore', null, null]});
-    let result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.error).to.be.an('error');
+  it("should croak if stdin is provided but stdio.stdin is disabled", async function () {
+    const stdin = of("a");
+    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");
   });
 
-  it('should subscribe to provided stdin', async function() {
-    let stdin = of('a');
-    let rxSpawn: Observable<{ source: any, text: any }> = spawn('marked', [], {split: true, stdin: stdin});
-    let result = await wrapSplitObservableInPromise(rxSpawn);
-    expect(result.stdout.trim()).to.be.equal('<p>a</p>');
+  it("should subscribe to provided stdin", async function () {
+    const stdin = of("a");
+    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>");
   });
-
 });