first-base 2.0.1 → 3.0.0

package/.node-version

@@ -1 +1 @@
-v24.13.0
+v24.14.1

package/.npm-version

@@ -1 +1 @@
-11.6.2
+11.11.0

package/README.md

@@ -183,3 +183,8 @@ The only things that changed between 1.x and 2.0 are:
   - Linux arm64 and x86_64
   - macOS arm64 and x86_64
   - Windows arm64 and x86_64
+
+## Upgrading from 2.x
+
+- The type definitions for `RunContext.write` and `RunContext.kill` were narrowed slightly. The runtime behavior of those methods didn't change.
+- `RunContext.debug()` is deprecated (but not removed). Use `spawn` option `debug: true` instead.

package/dist/find-root-dir.d.ts

@@ -0,0 +1 @@
+export declare function findRootDir(startingDir: string): string;

package/dist/find-root-dir.js

@@ -1,83 +1,51 @@
 "use strict";
-
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-var fs = require("fs");
-var _require = require("nice-path"),
-  Path = _require.Path;
-var strongRootDirIndicators = [".git", ".hg"];
-var weakRootDirIndicators = ["package-lock.json", ".gitignore", ".hgignore"];
-var veryWeakRootDirIndicators = ["package.json", "README.md"];
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRootDir = findRootDir;
+const fs_1 = __importDefault(require("fs"));
+const nice_path_1 = require("nice-path");
+const strongRootDirIndicators = [".git", ".hg"];
+const weakRootDirIndicators = ["package-lock.json", ".gitignore", ".hgignore"];
+const veryWeakRootDirIndicators = ["package.json", "README.md"];
 function hasFile(dir, filename) {
-  var fullPath = dir.concat(filename).toString();
-  try {
-    return fs.existsSync(fullPath);
-  } catch (err) {
-    return false;
-  }
+    const fullPath = dir.concat(filename).toString();
+    try {
+        return fs_1.default.existsSync(fullPath);
+    }
+    catch (err) {
+        return false;
+    }
 }
 function findRootDir(startingDir) {
-  var start = new Path(startingDir).normalize();
-  var searchDirs = [start];
-  var currentPath = start.replaceLast([]);
-  while (currentPath.segments.length > 0) {
-    searchDirs.push(currentPath);
-    currentPath = currentPath.replaceLast([]);
-  }
-  for (var _i = 0, _searchDirs = searchDirs; _i < _searchDirs.length; _i++) {
-    var dir = _searchDirs[_i];
-    var _iterator = _createForOfIteratorHelper(strongRootDirIndicators),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var indicator = _step.value;
-        if (hasFile(dir, indicator)) {
-          return dir.toString();
+    const start = new nice_path_1.Path(startingDir).normalize();
+    const searchDirs = [start];
+    let currentPath = start.replaceLast([]);
+    while (currentPath.segments.length > 0) {
+        searchDirs.push(currentPath);
+        currentPath = currentPath.replaceLast([]);
+    }
+    for (const dir of searchDirs) {
+        for (const indicator of strongRootDirIndicators) {
+            if (hasFile(dir, indicator)) {
+                return dir.toString();
+            }
         }
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
-  }
-  for (var _i2 = 0, _searchDirs2 = searchDirs; _i2 < _searchDirs2.length; _i2++) {
-    var _dir = _searchDirs2[_i2];
-    var _iterator2 = _createForOfIteratorHelper(weakRootDirIndicators),
-      _step2;
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var _indicator = _step2.value;
-        if (hasFile(_dir, _indicator)) {
-          return _dir.toString();
+    for (const dir of searchDirs) {
+        for (const indicator of weakRootDirIndicators) {
+            if (hasFile(dir, indicator)) {
+                return dir.toString();
+            }
         }
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
     }
-  }
-  for (var _i3 = 0, _searchDirs3 = searchDirs; _i3 < _searchDirs3.length; _i3++) {
-    var _dir2 = _searchDirs3[_i3];
-    var _iterator3 = _createForOfIteratorHelper(veryWeakRootDirIndicators),
-      _step3;
-    try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var _indicator2 = _step3.value;
-        if (hasFile(_dir2, _indicator2)) {
-          return _dir2.toString();
+    for (const dir of searchDirs) {
+        for (const indicator of veryWeakRootDirIndicators) {
+            if (hasFile(dir, indicator)) {
+                return dir.toString();
+            }
         }
-      }
-    } catch (err) {
-      _iterator3.e(err);
-    } finally {
-      _iterator3.f();
     }
-  }
-  return start.toString();
+    return start.toString();
 }
-module.exports = {
-  findRootDir: findRootDir
-};

package/dist/index.d.ts

@@ -1,73 +1,44 @@
+import { sanitizers } from "./sanitizers";
 export type Options = {
-  cwd?: string;
-  env?: { [varName: string]: any };
-  argv0?: string;
-  detached?: boolean;
-  uid?: number;
-  gid?: number;
-  shell?: boolean | string;
-  windowsVerbatimArguments?: boolean;
-  windowsHide?: boolean;
-  pty?: boolean;
+    cwd?: string;
+    env?: {
+        [varName: string]: string | undefined;
+    };
+    argv0?: string;
+    detached?: boolean;
+    uid?: number;
+    gid?: number;
+    shell?: boolean | string;
+    windowsVerbatimArguments?: boolean;
+    windowsHide?: boolean;
+    pty?: boolean;
+    debug?: boolean;
 };
-
 export type RunContext = {
-  result: {
-    stdout: string;
-    stderr: string;
-    code: null | number;
-    error: null | Error;
-  };
-  /**
-   * Same as {@link RunContext.result}, but with {@link sanitizers} run on
-   * stdout/stderr.
-   */
-  cleanResult(): {
-    stdout: string;
-    stderr: string;
-    code: null | number;
-    error: null | Error;
-  };
-  completion: Promise<void>;
-  debug(): RunContext;
-  outputContains(value: string | RegExp): Promise<void>;
-  clearOutputContainsBuffer(): void;
-  // TODO: Should be string | Buffer, but idk how to use Buffer since they might not be using node types
-  write(data: any): void;
-  close(stream: "stdin" | "stdout" | "stderr"): void;
-  kill(signal?: string): void;
+    result: {
+        stdout: string;
+        stderr: string;
+        code: null | number;
+        error: null | Error;
+    };
+    cleanResult(): {
+        stdout: string;
+        stderr: string;
+        code: null | number;
+        error: null | Error;
+    };
+    completion: Promise<void>;
+    /** @deprecated pass `debug: true` as an option to {@link spawn} instead. */
+    debug(): RunContext;
+    outputContains(value: string | RegExp): Promise<void>;
+    clearOutputContainsBuffer(): void;
+    write(data: string | Buffer): void;
+    close(stream: "stdin" | "stdout" | "stderr"): void;
+    kill(signal?: NodeJS.Signals): void;
 };
-
-export const spawn: ((cmd: string) => RunContext) &
-  ((cmd: string, args: Array<string>) => RunContext) &
-  ((cmd: string, options: Options) => RunContext) &
-  ((cmd: string, args: Array<string>, options: Options) => RunContext);
-
-/**
- * An array of functions that will be run on stdout/stderr when calling
- * {@link RunContext.cleanResult}.
- *
- * By default, it contains 5 functions, which are run in order:
- *
- * - `stripAnsi`: Removes ANSI control characters
- * - `replaceRootDir`: Replaces eg `/home/suchipi/Code/first-base/src/index.js` with `<rootDir>/src/index.js`
- *   - This function searches upwards for the root dir using a heuristic, and caches results in the {@link Map} `replaceRootDir.cache`.
- *   - The heuristic is:
- *     - Look upwards for a folder containing `.git` or `.hg`
- *     - if none is found, look upwards for a folder containing `package-lock.json`, `.gitignore` or `.hgignore`,
- *     - if none is found, look upwards for a folder containing `package.json` or `README.md`
- *     - if none is found, consider the present working directory to be the root dir.
- * - `replaceCwd`: Replaces the current working directory with `<cwd>`
- * - `collapseStackTrace`: For Node.JS-style stack traces, replaces the long chain of "at ..." lines with a single "at somewhere" line
- * - `omitThrowLineNumber`: For Node.JS error source display, removes the line number
- *
- * You can remove them or replace them or add to them by mutating the `sanitizers` Array.
- */
-export const sanitizers: Array<(str: string) => string>;
-
-/**
- * All runs that have been spawned which haven't reached completion.
- *
- * It may be beneficial to clean these up in a test timeout handler or etc.
- */
-export const allInflightRunContexts: Set<RunContext>;
+declare const allInflightRunContexts: Set<RunContext>;
+declare function spawn(cmd: string): RunContext;
+declare function spawn(cmd: string, args: Array<string>): RunContext;
+declare function spawn(cmd: string, options: Options): RunContext;
+declare function spawn(cmd: string, args: Array<string>, options: Options): RunContext;
+export { spawn, sanitizers, allInflightRunContexts };

package/dist/index.js

@@ -1,221 +1,289 @@
 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-var normalSpawn = require("child_process").spawn;
-var stripAnsi = require("strip-ansi");
-var _require = require("./sanitizers"),
-  sanitizers = _require.sanitizers;
-var allInflightRunContexts = new Set();
-
-// Run a child process and return a "run context" object
-// to interact with it. Function signature is the same as
-// child_process spawn, except you can pass `pty: true` in
-// options to run the process in a psuedo-tty.
-var spawn = function spawn(cmd, argsOrOptions, passedOptions) {
-  var args;
-  var options;
-  if (Array.isArray(argsOrOptions)) {
-    args = argsOrOptions;
-  } else if (_typeof(argsOrOptions) === "object") {
-    options = argsOrOptions;
-  }
-  if (passedOptions && !options) {
-    options = passedOptions;
-  }
-  if (!args) {
-    args = [];
-  }
-  if (!options) {
-    options = {};
-  }
-  var child;
-  var stdin;
-  var stdout;
-  var stderr;
-  var unreffable;
-  var running;
-  var _debug = false;
-  var outputContainsBuffer = "";
-  var pendingOutputContainsRequests = new Set();
-  var debugLog = function debugLog() {
-    if (_debug) {
-      var _console;
-      (_console = console).log.apply(_console, arguments);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allInflightRunContexts = exports.sanitizers = void 0;
+exports.spawn = spawn;
+const child_process_1 = require("child_process");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const sanitizers_1 = require("./sanitizers");
+Object.defineProperty(exports, "sanitizers", { enumerable: true, get: function () { return sanitizers_1.sanitizers; } });
+const allInflightRunContexts = new Set();
+exports.allInflightRunContexts = allInflightRunContexts;
+function spawn(cmd, argsOrOptions, passedOptions) {
+    let args;
+    let options;
+    if (Array.isArray(argsOrOptions)) {
+        args = argsOrOptions;
     }
-  };
-  var runContext = {
-    result: {
-      // All of the stdout and stderr the process has written so far.
-      stdout: "",
-      stderr: "",
-      // Exit status code, if the process has finished.
-      code: null,
-      // if the process errored out, this will be the Error
-      error: null
-    },
-    // Return a version of result which has had the string sanitizers run on it
-    cleanResult: function cleanResult() {
-      return Object.assign({}, runContext.result, {
-        stdout: sanitizers.reduce(function (str, transformFn) {
-          return transformFn(str);
-        }, runContext.result.stdout),
-        stderr: sanitizers.reduce(function (str, transformFn) {
-          return transformFn(str);
-        }, runContext.result.stderr)
-      });
-    },
-    // Promise that gets resolved when the child process completes.
-    completion: null,
-    debug: function debug() {
-      _debug = true;
-      return this;
-    },
-    // Returns a Promise that resolves once the child process output
-    // (combined stdout and stderr) contains the passed string or
-    // matches the passed RegExp. Ignores ansi control characters.
-    outputContains: function outputContains(value) {
-      debugLog("Waiting for output to contain ".concat(JSON.stringify(value), "..."));
-      return new Promise(function (resolve, reject) {
-        var request = {
-          value: value
-        };
-        request.resolve = function () {
-          pendingOutputContainsRequests["delete"](request);
-          resolve();
-        };
-        request.reject = function () {
-          pendingOutputContainsRequests["delete"](request);
-          reject();
-        };
-        pendingOutputContainsRequests.add(request);
-      });
-    },
-    clearOutputContainsBuffer: function clearOutputContainsBuffer() {
-      outputContainsBuffer = "";
-    },
-    // Call this function to write into stdin.
-    write: function write(data) {
-      stdin.write(data);
-    },
-    // Call this function to close stdin, stdout, or stderr.
-    close: function close(stream) {
-      switch (String(stream).toLowerCase()) {
-        case "stdin":
-          {
-            stdin.end();
-            break;
-          }
-        case "stdout":
-          {
-            stdout.end();
-            break;
-          }
-        case "stderr":
-          {
-            stderr.end();
-            break;
-          }
-        default:
-          {
-            throw new Error("Invalid stream name: '".concat(stream, "'. Valid names are 'stdin', 'stdout', or 'stderr'."));
-          }
-      }
-    },
-    // Call this function to send a signal to the child process.
-    // You can pass "SIGTERM", "SIGKILL", etc. Defaults to "SIGINT".
-    kill: function kill() {
-      var signal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "SIGINT";
-      if (running) {
-        child.kill(signal);
-      }
-      if (unreffable) {
-        unreffable.unref();
-      }
+    else if (typeof argsOrOptions === "object") {
+        options = argsOrOptions;
     }
-  };
-  if (options.pty) {
-    var ptySpawn = require("@lydell/node-pty").spawn;
-    child = ptySpawn(cmd, args, options);
-    stdin = child;
-    stdout = child;
-    stderr = null; // no way to tell between stdout and stderr with pty
-    unreffable = child.socket;
-  } else {
-    child = normalSpawn(cmd, args, options);
-    stdin = child.stdin;
-    stdout = child.stdout;
-    stderr = child.stderr;
-    unreffable = child;
-  }
-  running = true;
-  allInflightRunContexts.add(runContext);
-  var checkForPendingOutputRequestsToResolve = function checkForPendingOutputRequestsToResolve() {
-    pendingOutputContainsRequests.forEach(function (request) {
-      if (typeof request.value === "string") {
-        if (stripAnsi(outputContainsBuffer).indexOf(request.value) != -1) {
-          request.resolve();
-        }
-      } else if (request.value instanceof RegExp) {
-        if (request.value.test(stripAnsi(outputContainsBuffer))) {
-          request.resolve();
+    if (passedOptions && !options) {
+        options = passedOptions;
+    }
+    if (!args) {
+        args = [];
+    }
+    if (!options) {
+        options = {};
+    }
+    let child;
+    let stdin;
+    let stdout;
+    let stderr;
+    let unreffable = null;
+    let running;
+    let debug = options.debug ?? false;
+    let outputContainsBuffer = "";
+    let pendingOutputContainsRequests = new Set();
+    const disposables = [];
+    const debugLog = (...msg) => {
+        if (debug) {
+            console.log(...msg);
         }
-      }
-    });
-  };
-  stdout.setEncoding("utf-8");
-  var handleStdoutData = function handleStdoutData(data) {
-    runContext.result.stdout += data;
-    outputContainsBuffer += data;
-    debugLog("STDOUT: ".concat(data.toString()));
-    checkForPendingOutputRequestsToResolve();
-  };
-  if (stdout.onData) {
-    // the pty instance returned by node-pty
-    // requires attaching handlers differently
-    stdout.onData(handleStdoutData);
-  } else {
-    stdout.on("data", handleStdoutData);
-  }
-  if (stderr) {
-    stderr.setEncoding("utf-8");
-
-    // this is never a pty instance,
-    // so we don't need to deal with onData here:
-    stderr.on("data", function (data) {
-      runContext.result.stderr += data;
-      outputContainsBuffer += data;
-      debugLog("STDERR: ".concat(data.toString()));
-      checkForPendingOutputRequestsToResolve();
-    });
-  }
-  runContext.completion = new Promise(function (resolve) {
-    var finish = function finish(reason) {
-      debugLog("Process ".concat(reason));
-      debugLog(runContext.result);
-      running = false;
-      allInflightRunContexts["delete"](runContext);
-      resolve();
-      pendingOutputContainsRequests.forEach(function (request) {
-        request.reject(new Error("Child process ".concat(reason, " before its output contained the requested content: ").concat(request.value)));
-      });
     };
-    child.once("exit", function (code) {
-      runContext.result.code = code;
-      finish("exited");
-    });
-    child.once("error", function (error) {
-      if (_typeof(error) === "object" && error !== null && error.code === "EIO") {
-        // not real; process is about to exit
-        return;
-      }
-      runContext.result.error = error;
-      finish("errored");
+    const runContext = {
+        result: {
+            // All of the stdout and stderr the process has written so far.
+            stdout: "",
+            stderr: "",
+            // Exit status code, if the process has finished.
+            code: null,
+            // if the process errored out, this will be the Error
+            error: null,
+        },
+        // Return a version of result which has had the string sanitizers run on it
+        cleanResult() {
+            return Object.assign({}, runContext.result, {
+                stdout: sanitizers_1.sanitizers.reduce((str, transformFn) => transformFn(str), runContext.result.stdout),
+                stderr: sanitizers_1.sanitizers.reduce((str, transformFn) => transformFn(str), runContext.result.stderr),
+            });
+        },
+        // Promise that gets resolved when the child process completes.
+        // Actual value gets filled in below.
+        completion: Promise.resolve(),
+        debug() {
+            debug = true;
+            return this;
+        },
+        // Returns a Promise that resolves once the child process output
+        // (combined stdout and stderr) contains the passed string or
+        // matches the passed RegExp. Ignores ansi control characters.
+        outputContains(value) {
+            debugLog(`Waiting for output to contain ${JSON.stringify(value)}...`);
+            return new Promise((resolve, reject) => {
+                const request = { value, resolve: undefined, reject: undefined };
+                request.resolve = () => {
+                    pendingOutputContainsRequests.delete(request);
+                    resolve();
+                };
+                request.reject = (error) => {
+                    pendingOutputContainsRequests.delete(request);
+                    reject(error);
+                };
+                pendingOutputContainsRequests.add(request);
+            });
+        },
+        clearOutputContainsBuffer() {
+            outputContainsBuffer = "";
+        },
+        // Call this function to write into stdin.
+        write(data) {
+            stdin.write(data);
+        },
+        // Call this function to close stdin, stdout, or stderr.
+        close(stream) {
+            switch (String(stream).toLowerCase()) {
+                case "stdin": {
+                    if ("end" in stdin) {
+                        stdin.end();
+                    }
+                    break;
+                }
+                case "stdout": {
+                    if ("destroy" in stdout) {
+                        stdout.destroy();
+                    }
+                    break;
+                }
+                case "stderr": {
+                    if (stderr != null && "destroy" in stderr) {
+                        stderr.destroy();
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error(`Invalid stream name: '${stream}'. Valid names are 'stdin', 'stdout', or 'stderr'.`);
+                }
+            }
+        },
+        // Call this function to send a signal to the child process.
+        // You can pass "SIGTERM", "SIGKILL", etc. Defaults to "SIGINT".
+        kill(signal = "SIGINT") {
+            if (running) {
+                child.kill(signal);
+            }
+            if (unreffable != null) {
+                unreffable.unref();
+            }
+        },
+    };
+    if (options.pty) {
+        debugLog("pty option was true; using node-pty");
+        const ptySpawn = require("@lydell/node-pty").spawn;
+        const ptyChild = ptySpawn(cmd, args, options);
+        child = ptyChild;
+        stdin = ptyChild;
+        stdout = ptyChild;
+        stderr = null; // no way to tell between stdout and stderr with pty
+        // no unreffable equivalent on ptyChild
+    }
+    else {
+        debugLog("pty option was NOT true; using child_process");
+        const nonPtyChild = (0, child_process_1.spawn)(cmd, args, options);
+        child = nonPtyChild;
+        stdin = nonPtyChild.stdin;
+        stdout = nonPtyChild.stdout;
+        stderr = nonPtyChild.stderr;
+        unreffable = nonPtyChild;
+    }
+    running = true;
+    allInflightRunContexts.add(runContext);
+    if ("on" in child) {
+        debugLog("using 'on' method to listen for child spawn event");
+        child.on("spawn", () => {
+            debugLog("'spawn' event");
+        });
+    }
+    else {
+        debugLog("child had no 'on' method, so child spawn event listener wasn't set up");
+    }
+    const checkForPendingOutputRequestsToResolve = () => {
+        pendingOutputContainsRequests.forEach((request) => {
+            if (typeof request.value === "string") {
+                if ((0, strip_ansi_1.default)(outputContainsBuffer).indexOf(request.value) != -1) {
+                    request.resolve();
+                }
+            }
+            else if (request.value instanceof RegExp) {
+                if (request.value.test((0, strip_ansi_1.default)(outputContainsBuffer))) {
+                    request.resolve();
+                }
+            }
+        });
+    };
+    if ("setEncoding" in stdout) {
+        debugLog("setting stdout encoding to utf-8");
+        stdout.setEncoding("utf-8");
+    }
+    else {
+        debugLog("not setting stdout encoding because the setEncoding method was not present");
+    }
+    const handleStdoutData = (data) => {
+        runContext.result.stdout += data;
+        outputContainsBuffer += data;
+        debugLog(`STDOUT: ${data.toString()}`);
+        checkForPendingOutputRequestsToResolve();
+    };
+    if ("onData" in stdout) {
+        debugLog("using 'onData' method to listen for stdout data event");
+        // the pty instance returned by node-pty
+        // requires attaching handlers differently
+        stdout.onData(handleStdoutData);
+    }
+    else {
+        debugLog("using 'on' method to listen for stdout data event");
+        stdout.on("data", handleStdoutData);
+    }
+    if (stderr) {
+        debugLog("setting stderr encoding to utf-8");
+        stderr.setEncoding("utf-8");
+        // this is never a pty instance,
+        // so we don't need to deal with onData here:
+        debugLog("using 'on' method to listen for stderr data event");
+        stderr.on("data", (data) => {
+            runContext.result.stderr += data;
+            outputContainsBuffer += data;
+            debugLog(`STDERR: ${data.toString()}`);
+            checkForPendingOutputRequestsToResolve();
+        });
+    }
+    else {
+        debugLog("stderr isn't present (pty mixes stdout and stderr together), so not setting encoding or setting up data event listener for stderr");
+    }
+    runContext.completion = new Promise((resolve) => {
+        let hasFinished = false;
+        const finish = (reason) => {
+            debugLog("in finish", runContext.result);
+            if (hasFinished) {
+                debugLog("finish called more than once; ignoring");
+            }
+            else {
+                running = false;
+                allInflightRunContexts.delete(runContext);
+                resolve();
+                for (const request of pendingOutputContainsRequests) {
+                    request.reject(new Error(`Child process ${reason} before its output contained the requested content: ${request.value}`));
+                }
+                for (const disposable of disposables) {
+                    disposable.dispose();
+                }
+                hasFinished = true;
+            }
+        };
+        if ("on" in child) {
+            debugLog("using 'on' method to listen for child close event");
+            child.on("close", (code, signal) => {
+                debugLog("'close' event", { code, signal });
+                if (code != null) {
+                    runContext.result.code = code;
+                }
+            });
+        }
+        else {
+            debugLog("child had no 'on' method, so child close event listener wasn't set up");
+        }
+        if ("onExit" in child) {
+            debugLog("using 'onExit' method to listen for child exit event");
+            const disposable = child.onExit(({ exitCode, signal }) => {
+                debugLog("onExit", { exitCode, signal });
+                if (exitCode != null) {
+                    runContext.result.code = exitCode;
+                }
+                finish("exited");
+            });
+            disposables.push(disposable);
+        }
+        else {
+            debugLog("using 'on' method to listen for child exit event");
+            child.on("exit", (code) => {
+                debugLog("'exit' event", { code });
+                if (code != null) {
+                    runContext.result.code = code;
+                }
+                finish("exited");
+            });
+        }
+        if ("on" in child) {
+            debugLog("using 'on' method to listen for child error event");
+            child.on("error", (error) => {
+                debugLog("'error' event", { error });
+                if (typeof error === "object" &&
+                    error !== null &&
+                    error.code === "EIO") {
+                    // not real; process is about to exit
+                    debugLog("Ignoring spurious EIO error:", error);
+                    return;
+                }
+                runContext.result.error = error;
+                finish("errored");
+            });
+        }
+        else {
+            debugLog("child had no 'on' method, so child error event listener wasn't set up");
+        }
     });
-  });
-  return runContext;
-};
-module.exports = {
-  spawn: spawn,
-  sanitizers: sanitizers,
-  allInflightRunContexts: allInflightRunContexts
-};
+    return runContext;
+}

package/dist/index.js.flow

@@ -1,7 +1,7 @@
 // @flow
 export type Options = {
   cwd?: ?string,
-  env?: ?{ [varName: string]: any },
+  env?: ?{ [varName: string]: string | undefined },
   argv0?: ?string,
   detached?: ?boolean,
   uid?: ?number,
@@ -10,6 +10,7 @@ export type Options = {
   windowsVerbatimArguments?: ?boolean,
   windowsHide?: ?boolean,
   pty?: ?boolean,
+  debug?: ?boolean,
 };
 
 export type RunContext = {

package/dist/sanitizers.d.ts

@@ -0,0 +1 @@
+export declare const sanitizers: Array<(str: string) => string>;

package/dist/sanitizers.js

@@ -1,32 +1,39 @@
 "use strict";
-
-var stripAnsi = require("strip-ansi");
-var _require = require("./find-root-dir"),
-  findRootDir = _require.findRootDir;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizers = void 0;
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const find_root_dir_1 = require("./find-root-dir");
 function escapeRegex(str) {
-  return str.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
+    return str.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-var sanitizers = [stripAnsi, Object.assign(function replaceRootDir(str) {
-  var here = process.cwd();
-  var rootDir = replaceRootDir.cache.get(here) || findRootDir(here);
-  replaceRootDir.cache.set(here, rootDir);
-  return str.replace(new RegExp(escapeRegex(rootDir), "g"), "<rootDir>");
+const replaceRootDir = Object.assign(function _replaceRootDir(str) {
+    const here = process.cwd();
+    const rootDir = replaceRootDir.cache.get(here) || (0, find_root_dir_1.findRootDir)(here);
+    replaceRootDir.cache.set(here, rootDir);
+    return str.replace(new RegExp(escapeRegex(rootDir), "g"), "<rootDir>");
 }, {
-  cache: new Map()
-}), function replaceCwd(str) {
-  return str.replace(new RegExp(escapeRegex(process.cwd()), "g"), "<cwd>");
-}, function collapseStackTrace(str) {
-  return str
-  // replace stack trace lines with a single "at somewhere" line
-  // explanation of regexp:
-  //   newline, optional ansi escape, zero or more whitespace(s), "at",
-  //   whitespace(s), several non-newline characters... and that whole
-  //   thing can happen more than once
-  .replaceAll(/(?:\n(?:\x1B\[\d+m)?(\s*)at\s+[^\n]+)+/g, "\n$1at somewhere");
-}, function omitThrowLineNumber(str) {
-  // omit line number from eg. "<rootDir>/dist/match.js:57\n\t\t\t\tthrow"
-  return str.replaceAll(/(\.js):\d+(\s+throw)/g, "$1$2");
-}];
-module.exports = {
-  sanitizers: sanitizers
-};
+    cache: new Map(),
+});
+exports.sanitizers = [
+    strip_ansi_1.default,
+    replaceRootDir,
+    function replaceCwd(str) {
+        return str.replace(new RegExp(escapeRegex(process.cwd()), "g"), "<cwd>");
+    },
+    function collapseStackTrace(str) {
+        return (str
+            // replace stack trace lines with a single "at somewhere" line
+            // explanation of regexp:
+            //   newline, optional ansi escape, zero or more whitespace(s), "at",
+            //   whitespace(s), several non-newline characters... and that whole
+            //   thing can happen more than once
+            .replaceAll(/(?:\n(?:\x1B\[\d+m)?(\s*)at\s+[^\n]+)+/g, "\n$1at somewhere"));
+    },
+    function omitThrowLineNumber(str) {
+        // omit line number from eg. "<rootDir>/dist/match.js:57\n\t\t\t\tthrow"
+        return str.replaceAll(/(\.js):\d+(\s+throw)/g, "$1$2");
+    },
+];

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "first-base",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Integration testing for CLI applications",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/suchipi/first-base.git"
@@ -15,22 +16,13 @@
     "strip-ansi": "^5.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.28.6",
-    "@babel/core": "^7.29.0",
-    "@babel/preset-env": "^7.29.0",
-    "babel-core": "^7.0.0-bridge.0",
-    "babel-jest": "^30.2.0",
-    "eslint": "^8.56.0",
-    "eslint-config-unobtrusive": "^1.2.5",
-    "eslint-plugin-import": "^2.29.1",
-    "jest": "^30.2.0",
-    "prettier": "^3.8.1"
+    "@types/node": "^22.0.0",
+    "prettier": "^3.8.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "scripts": {
-    "build": "mkdir -p dist; rm -rf dist/*; babel src --out-dir dist && cp src/index.js.flow dist/ && cp src/index.d.ts dist/",
-    "test": "jest"
-  },
-  "jest": {
-    "prettierPath": null
+    "build": "mkdir -p dist; rm -rf dist/*; tsc && rm -f dist/*.test.js dist/*.test.d.ts && cp src/index.js.flow dist/",
+    "test": "vitest run"
   }
 }

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "include": ["src/**/*.ts"],
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"],
+
+    // need this because @lydell/node-pty/package.json specifies "types" field
+    // but its "exports" field doesn't have "types".
+    //
+    // We can remove this after this is merged: https://github.com/lydell/node-pty/pull/15
+    "moduleResolution": "Node10",
+    "ignoreDeprecations": "6.0"
+  }
+}