Meta tweaks

index.d.ts

@@ -1,6 +1,6 @@
-import {Buffer} from 'node:buffer';
-import {ChildProcess} from 'node:child_process';
-import {Stream, Readable as ReadableStream} from 'node:stream';
+import {type Buffer} from 'node:buffer';
+import {type ChildProcess} from 'node:child_process';
+import {type Stream, type Readable as ReadableStream} from 'node:stream';
 
 export type StdioOption =
  | 'pipe'
@@ -12,7 +12,7 @@ export type StdioOption =
  | number
  | undefined;
 
-export interface CommonOptions<EncodingType> {
+export type CommonOptions<EncodingType> = {
  /**
  Kill the spawned process when the parent process exits unless either:
  - the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)
@@ -244,23 +244,23 @@ export interface CommonOptions<EncodingType> {
  @default true
  */
  readonly windowsHide?: boolean;
-}
+};
 
-export interface Options<EncodingType = string> extends CommonOptions<EncodingType> {
+export type Options<EncodingType = string> = {
  /**
  Write some input to the `stdin` of your binary.
  */
  readonly input?: string | Buffer | ReadableStream;
-}
+} & CommonOptions<EncodingType>;
 
-export interface SyncOptions<EncodingType = string> extends CommonOptions<EncodingType> {
+export type SyncOptions<EncodingType = string> = {
  /**
  Write some input to the `stdin` of your binary.
  */
  readonly input?: string | Buffer;
-}
+} & CommonOptions<EncodingType>;
 
-export interface NodeOptions<EncodingType = string> extends Options<EncodingType> {
+export type NodeOptions<EncodingType = string> = {
  /**
  The Node.js executable to use.
 
@@ -274,9 +274,9 @@ export interface NodeOptions<EncodingType = string> extends Options<EncodingType
  @default process.execArgv
  */
  readonly nodeOptions?: string[];
-}
+} & Options<EncodingType>;
 
-export interface ExecaReturnBase<StdoutStderrType> {
+export type ExecaReturnBase<StdoutStderrType> = {
  /**
  The file and arguments that were run, for logging purposes.
 
@@ -335,11 +335,10 @@ export interface ExecaReturnBase<StdoutStderrType> {
  If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.
  */
  signalDescription?: string;
-}
+};
 
-export interface ExecaSyncReturnValue<StdoutErrorType = string>
- extends ExecaReturnBase<StdoutErrorType> {
-}
+export type ExecaSyncReturnValue<StdoutErrorType = string> = {
+} & ExecaReturnBase<StdoutErrorType>;
 
 /**
 Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.
@@ -351,8 +350,7 @@ The child process fails when:
 - being canceled
 - there's not enough memory or there are already too many child processes
 */
-export interface ExecaReturnValue<StdoutErrorType = string>
- extends ExecaSyncReturnValue<StdoutErrorType> {
+export type ExecaReturnValue<StdoutErrorType = string> = {
  /**
  The output of the process with `stdout` and `stderr` interleaved.
 
@@ -368,11 +366,9 @@ export interface ExecaReturnValue<StdoutErrorType = string>
  You can cancel the spawned process using the [`signal`](https://github.com/sindresorhus/execa#signal-1) option.
  */
  isCanceled: boolean;
-}
+} & ExecaSyncReturnValue<StdoutErrorType>;
 
-export interface ExecaSyncError<StdoutErrorType = string>
- extends Error,
- ExecaReturnBase<StdoutErrorType> {
+export type ExecaSyncError<StdoutErrorType = string> = {
  /**
  Error message when the child process failed to run. In addition to the underlying error message, it also contains some information related to why the child process errored.
 
@@ -391,10 +387,9 @@ export interface ExecaSyncError<StdoutErrorType = string>
  This is `undefined` unless the child process exited due to an `error` event or a timeout.
  */
  originalMessage?: string;
-}
+} & Error & ExecaReturnBase<StdoutErrorType>;
 
-export interface ExecaError<StdoutErrorType = string>
- extends ExecaSyncError<StdoutErrorType> {
+export type ExecaError<StdoutErrorType = string> = {
  /**
  The output of the process with `stdout` and `stderr` interleaved.
 
@@ -408,9 +403,9 @@ export interface ExecaError<StdoutErrorType = string>
  Whether the process was canceled.
  */
  isCanceled: boolean;
-}
+} & ExecaSyncError<StdoutErrorType>;
 
-export interface KillOptions {
+export type KillOptions = {
  /**
  Milliseconds to wait for the child process to terminate before sending `SIGKILL`.
 
@@ -419,9 +414,9 @@ export interface KillOptions {
  @default 5000
  */
  forceKillAfterTimeout?: number | false;
-}
+};
 
-export interface ExecaChildPromise<StdoutErrorType> {
+export type ExecaChildPromise<StdoutErrorType> = {
  /**
  Stream combining/interleaving [`stdout`](https://nodejs.org/api/child_process.html#child_process_subprocess_stdout) and [`stderr`](https://nodejs.org/api/child_process.html#child_process_subprocess_stderr).
 
@@ -444,7 +439,7 @@ export interface ExecaChildPromise<StdoutErrorType> {
  Similar to [`childProcess.kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal). This used to be preferred when cancelling the child process execution as the error is more descriptive and [`childProcessResult.isCanceled`](#iscanceled) is set to `true`. But now this is deprecated and you should either use `.kill()` or the `signal` option when creating the child process.
  */
  cancel(): void;
-}
+};
 
 export type ExecaChildProcess<StdoutErrorType = string> = ChildProcess &
 ExecaChildPromise<StdoutErrorType> &

index.test-d.ts

@@ -3,19 +3,19 @@ import {Buffer} from 'node:buffer';
 // `process.stdin`, `process.stderr`, and `process.stdout`
 // to get treated as `any` by `@typescript-eslint/no-unsafe-assignment`.
 import * as process from 'node:process';
-import {Readable as ReadableStream} from 'node:stream';
+import {type Readable as ReadableStream} from 'node:stream';
 import {expectType, expectError} from 'tsd';
 import {
  execa,
  execaSync,
  execaCommand,
  execaCommandSync,
  execaNode,
- ExecaReturnValue,
- ExecaChildProcess,
- ExecaError,
- ExecaSyncReturnValue,
- ExecaSyncError,
+ type ExecaReturnValue,
+ type ExecaChildProcess,
+ type ExecaError,
+ type ExecaSyncReturnValue,
+ type ExecaSyncError,
 } from './index.js';
 
 try {

lib/promise.js

@@ -1,4 +1,6 @@
+// eslint-disable-next-line unicorn/prefer-top-level-await
 const nativePromisePrototype = (async () => {})().constructor.prototype;
+
 const descriptors = ['then', 'catch', 'finally'].map(property => [
  property,
  Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),

package.json

@@ -43,7 +43,7 @@
  "dependencies": {
  "cross-spawn": "^7.0.3",
  "get-stream": "^6.0.1",
- "human-signals": "^4.1.0",
+ "human-signals": "^4.3.0",
  "is-stream": "^3.0.0",
  "merge-stream": "^2.0.0",
  "npm-run-path": "^5.1.0",
@@ -52,16 +52,16 @@
  "strip-final-newline": "^3.0.0"
  },
  "devDependencies": {
- "@types/node": "^17.0.17",
- "ava": "^4.0.1",
- "c8": "^7.11.0",
- "get-node": "^12.0.0",
+ "@types/node": "^18.13.0",
+ "ava": "^5.2.0",
+ "c8": "^7.12.0",
+ "get-node": "^13.5.0",
  "is-running": "^2.1.0",
  "p-event": "^5.0.1",
  "path-key": "^4.0.0",
  "tempfile": "^4.0.0",
- "tsd": "^0.19.1",
- "xo": "^0.48.0"
+ "tsd": "^0.25.0",
+ "xo": "^0.53.1"
  },
  "c8": {
  "reporter": [
@@ -74,6 +74,9 @@
  "**/test/**"
  ]
  },
+ "ava": {
+ "workerThreads": false
+ },
  "xo": {
  "rules": {
  "unicorn/no-empty-file": "off",

test/fixtures/sub-process-exit.js

@@ -5,13 +5,9 @@ import {execa} from '../../index.js';
 const cleanup = process.argv[2] === 'true';
 const detached = process.argv[3] === 'true';
 
-const runChild = async () => {
- try {
- await execa('node', ['./test/fixtures/noop.js'], {cleanup, detached});
- } catch (error) {
- console.error(error);
- process.exit(1);
- }
-};
-
-runChild();
+try {
+ await execa('node', ['./test/fixtures/noop.js'], {cleanup, detached});
+} catch (error) {
+ console.error(error);
+ process.exit(1);
+}

test/test.js

@@ -104,9 +104,9 @@ test('localDir option', async t => {
 });
 
 test('execPath option', async t => {
- const {path: execPath} = await getNode('6.0.0');
+ const {path: execPath} = await getNode('16.0.0');
  const {stdout} = await execa('node', ['-p', 'process.env.Path || process.env.PATH'], {preferLocal: true, execPath});
- t.true(stdout.includes('6.0.0'));
+ t.true(stdout.includes('16.0.0'));
 });
 
 test('stdin errors are handled', async t => {