		{
		"name": "@vltpkg/promise-spawn",
		"description": "Spawn a process and return a promise that resolves when it finishes",
		"version": "1.0.0-rc.18",
		"version": "1.0.0-rc.22",
		"repository": {
		@@ -10,5 +10,8 @@ "type": "git",
		},
		"author": "vlt technology inc. <support@vlt.sh> (http://vlt.sh)",
		"author": {
		"name": "vlt technology inc.",
		"email": "support@vlt.sh"
		},
		"dependencies": {
		"@vltpkg/error-cause": "1.0.0-rc.18"
		"@vltpkg/error-cause": "1.0.0-rc.22"
		},
		@@ -28,4 +31,15 @@ "devDependencies": {
		"engines": {
		"node": ">=22.9.0"
		"node": ">=22.22.0"
		},
		"scripts": {
		"format": "prettier --write . --log-level warn --ignore-path ../../.prettierignore --cache",
		"format:check": "prettier --check . --ignore-path ../../.prettierignore --cache",
		"lint": "eslint . --fix",
		"lint:check": "eslint .",
		"prepack": "tsc -p tsconfig.publish.json && ../../scripts/update-dist-exports.ts",
		"snap": "tap",
		"test": "tap",
		"posttest": "tsc --noEmit",
		"typecheck": "tsc --noEmit"
		},
		"tap": {
		@@ -35,3 +49,3 @@ "extends": "../../tap-config.yaml"
		"prettier": "../../.prettierrc.js",
		"module": "./dist/index.js",
		"module": "./src/index.ts",
		"type": "module",
		@@ -42,3 +56,3 @@ "exports": {
		"import": {
		"default": "./dist/index.js"
		"default": "./src/index.ts"
		}
		@@ -49,13 +63,3 @@ }
		"dist"
		],
		"scripts": {
		"format": "prettier --write . --log-level warn --ignore-path ../../.prettierignore --cache",
		"format:check": "prettier --check . --ignore-path ../../.prettierignore --cache",
		"lint": "eslint . --fix",
		"lint:check": "eslint .",
		"snap": "tap",
		"test": "tap",
		"posttest": "tsc --noEmit",
		"typecheck": "tsc --noEmit"
		}
		}
		]
		}

-154

dist/index.d.ts

		import type { ChildProcess, IOType, SpawnOptions, StdioOptions } from 'node:child_process';
		export type IOTypeNoPipe = Exclude<IOType, IOTypePipe>;
		export type IOTypePipe = 'overlapped' \| 'pipe' \| null \| undefined;
		export interface PromiseSpawnOptions extends SpawnOptions {
		stdioString?: boolean;
		acceptFail?: boolean;
		}
		export interface PromiseSpawnOptionsString extends PromiseSpawnOptions {
		stdioString?: true;
		}
		export interface PromiseSpawnOptionsBuffer extends PromiseSpawnOptions {
		stdioString: false;
		}
		export interface PromiseSpawnOptionsStdin extends PromiseSpawnOptions {
		stdio?: Exclude<IOTypePipe, null> \| [
		stdin?: IOTypePipe,
		stdout?: Exclude<StdioOptions, IOType>[number],
		stderr?: Exclude<StdioOptions, IOType>[number]
		];
		}
		export interface PromiseSpawnOptionsNoStdin extends PromiseSpawnOptions {
		stdio: IOTypeNoPipe \| IOTypeNoPipe[] \| [
		stdin: IOTypeNoPipe \| number,
		stdout?: Exclude<StdioOptions, IOType>[number],
		stderr?: Exclude<StdioOptions, IOType>[number]
		];
		}
		export interface PromiseSpawnOptionsStdout extends PromiseSpawnOptions {
		stdio?: Exclude<IOTypePipe, null> \| [
		stdin: Exclude<StdioOptions, IOType>[number] \| undefined,
		stdout?: IOTypePipe,
		stderr?: Exclude<StdioOptions, IOType>[number]
		];
		}
		export interface PromiseSpawnOptionsStdoutString extends PromiseSpawnOptionsStdout {
		stdioString?: true;
		}
		export interface PromiseSpawnOptionsStdoutBuffer extends PromiseSpawnOptionsStdout {
		stdioString: false;
		}
		export interface PromiseSpawnOptionsNoStdout extends PromiseSpawnOptions {
		stdio: IOTypeNoPipe \| IOTypeNoPipe[] \| [
		stdin: Exclude<StdioOptions, IOType>[number] \| undefined,
		stdout?: IOTypeNoPipe,
		stderr?: Exclude<StdioOptions, IOType>[number]
		];
		}
		export interface PromiseSpawnOptionsStderr extends PromiseSpawnOptions {
		stdio?: Exclude<IOTypePipe, null> \| [
		stdin: Exclude<StdioOptions, IOType>[number] \| undefined,
		stdout: Exclude<StdioOptions, IOType>[number] \| undefined,
		stderr?: IOTypePipe
		];
		}
		export interface PromiseSpawnOptionsStderrString extends PromiseSpawnOptionsStderr {
		stdioString?: true;
		}
		export interface PromiseSpawnOptionsStderrBuffer extends PromiseSpawnOptionsStderr {
		stdioString: false;
		}
		export interface PromiseSpawnOptionsNoStderr extends PromiseSpawnOptions {
		stdio: IOTypeNoPipe \| IOTypeNoPipe[] \| [
		stdin: Exclude<StdioOptions, IOType>[number] \| undefined,
		stdout: Exclude<StdioOptions, IOType>[number] \| undefined,
		stderr: IOTypeNoPipe
		];
		}
		export interface SpawnResult {
		command: string;
		args: string[];
		cwd: string;
		status: number \| null;
		signal: NodeJS.Signals \| null;
		stdout: Buffer \| string \| null;
		stderr: Buffer \| string \| null;
		}
		export interface SpawnResultString extends SpawnResult {
		stdout: string \| null;
		stderr: string \| null;
		}
		export interface SpawnResultBuffer extends SpawnResult {
		stdout: Buffer \| null;
		stderr: Buffer \| null;
		}
		export interface SpawnResultStdout extends SpawnResult {
		stdout: Buffer \| string;
		}
		export interface SpawnResultStdoutString extends SpawnResultString {
		stdout: string;
		}
		export interface SpawnResultStdoutBuffer extends SpawnResultBuffer {
		stdout: Buffer;
		}
		export interface SpawnResultNoStdout extends SpawnResult {
		stdout: null;
		}
		export interface SpawnResultStderr extends SpawnResult {
		stderr: Buffer \| string;
		}
		export interface SpawnResultStderrString extends SpawnResultString {
		stderr: string;
		}
		export interface SpawnResultStderrBuffer extends SpawnResultBuffer {
		stderr: Buffer;
		}
		export interface SpawnResultNoStderr extends SpawnResult {
		stderr: null;
		}
		export interface SpawnResultNoStdio extends SpawnResult {
		stderr: null;
		stdout: null;
		}
		export interface SpawnResultStdioStrings extends SpawnResult {
		stdout: string;
		stderr: string;
		}
		export interface SpawnResultStdioBuffers extends SpawnResult {
		stdout: Buffer;
		stderr: Buffer;
		}
		export type Override<T, R> = Omit<T, keyof R> & R;
		export type SpawnResultByOptions<T extends PromiseSpawnOptions> = Override<SpawnResult, {
		stdout: T extends PromiseSpawnOptionsNoStdout ? null : T extends PromiseSpawnOptionsStdoutBuffer ? Buffer : T extends PromiseSpawnOptionsStdoutString ? string : T extends PromiseSpawnOptionsBuffer ? Buffer \| null : T extends PromiseSpawnOptionsString ? string \| null : Buffer \| string \| null;
		stderr: T extends PromiseSpawnOptionsNoStderr ? null : T extends PromiseSpawnOptionsStderrBuffer ? Buffer : T extends PromiseSpawnOptionsStderrString ? string : T extends PromiseSpawnOptionsBuffer ? Buffer \| null : T extends PromiseSpawnOptionsString ? string \| null : Buffer \| string \| null;
		}>;
		export type ChildProcessByOptions<T extends PromiseSpawnOptions> = Override<ChildProcess, {
		stdin: T extends PromiseSpawnOptionsNoStdin ? null : Exclude<ChildProcess['stdin'], null>;
		stdout: T extends PromiseSpawnOptionsNoStdout ? null : Exclude<ChildProcess['stdout'], null>;
		stderr: T extends PromiseSpawnOptionsNoStderr ? null : Exclude<ChildProcess['stderr'], null>;
		}>;
		/**
		* Subtype of Promise returned by {@link promiseSpawn}.
		*
		* Resolution value is inferred from the provided options.
		*/
		export declare class SpawnPromise<O extends PromiseSpawnOptions, T extends object = object> extends Promise<SpawnResultByOptions<O> & T> {
		[Symbol.toStringTag]: string;
		/** The spawned process this promise references */
		process: ChildProcessByOptions<O>;
		/** Expose the child process stdin, if available */
		stdin: ChildProcessByOptions<O>['stdin'];
		/**
		* Set static `Symbol.species` back to the base Promise class so that
		* v8 doesn't get confused by the changed constructor signature.
		*/
		static get [Symbol.species](): PromiseConstructor;
		constructor(command: string, args: string[], opts: O, extra?: T);
		}
		/**
		* Spawn the specified command, and return a promise that resolves when
		* the process closes or has an error.
		*/
		export declare function promiseSpawn<O extends PromiseSpawnOptions = PromiseSpawnOptionsStderrString & PromiseSpawnOptionsStdoutString, E extends object = object>(command: string, args: string[], opts?: O, extra?: E): SpawnPromise<O, E>;
		//# sourceMappingURL=index.d.ts.map

-1

dist/index.d.ts.map

-107

dist/index.js

		import { error } from '@vltpkg/error-cause';
		import { spawn } from 'node:child_process';
		const isPipe = (stdio = 'pipe', fd) => stdio === 'pipe' \|\| stdio === 'overlapped' \|\| stdio === null ? true
		: Array.isArray(stdio) ? isPipe(stdio[fd], fd)
		: false;
		function stdioResult(stdout, stderr, o) {
		return {
		stdout: (!isPipe(o.stdio, 1) ? null
		: o.stdioString !== false ?
		Buffer.concat(stdout).toString().trim()
		: Buffer.concat(stdout)),
		stderr: (!isPipe(o.stdio, 2) ? null
		: o.stdioString !== false ?
		Buffer.concat(stderr).toString().trim()
		: Buffer.concat(stderr)),
		};
		}
		/**
		* Subtype of Promise returned by {@link promiseSpawn}.
		*
		* Resolution value is inferred from the provided options.
		*/
		export class SpawnPromise extends Promise {
		[Symbol.toStringTag] = 'SpawnPromise';
		/** The spawned process this promise references */
		process;
		/** Expose the child process stdin, if available */
		stdin;
		/**
		* Set static `Symbol.species` back to the base Promise class so that
		* v8 doesn't get confused by the changed constructor signature.
		*/
		static get [Symbol.species]() {
		return Promise;
		}
		constructor(command, args, opts, extra = {}) {
		let proc;
		super((res, rej) => {
		proc = spawn(command, args, opts);
		const stdout = [];
		const stderr = [];
		// Don't use the spread operator on successResult or errorResult
		// as that kills any typechecking for the known keys.
		const reject = (er, status, signal) => {
		const stdio = stdioResult(stdout, stderr, opts);
		const errorResult = {
		command,
		args,
		stdout: stdio.stdout,
		stderr: stdio.stderr,
		cwd: opts.cwd?.toString() ?? process.cwd(),
		};
		if (er !== undefined) {
		errorResult.cause = er;
		}
		if (status !== undefined) {
		errorResult.status = status;
		}
		/* c8 ignore next 3 - hard to test on win32 so coverage fails */
		if (signal !== undefined) {
		errorResult.signal = signal;
		}
		Object.assign(errorResult, extra);
		rej(error('command failed', errorResult));
		};
		const resolve = (status, signal) => {
		const stdio = stdioResult(stdout, stderr, opts);
		const successResult = {
		command,
		args,
		status,
		signal,
		stdout: stdio.stdout,
		stderr: stdio.stderr,
		cwd: opts.cwd?.toString() ?? process.cwd(),
		};
		Object.assign(successResult, extra);
		res(successResult);
		};
		proc.on('error', reject);
		proc.stdout
		?.on('data', c => stdout.push(c))
		.on('error', reject);
		proc.stderr
		?.on('data', c => stderr.push(c))
		.on('error', reject);
		proc.on('close', (status, signal) => {
		if ((status \|\| signal) && !opts.acceptFail) {
		reject(undefined, status, signal);
		}
		else {
		resolve(status, signal);
		}
		});
		});
		this.process = proc;
		this.stdin = proc.stdin;
		}
		}
		/**
		* Spawn the specified command, and return a promise that resolves when
		* the process closes or has an error.
		*/
		export function promiseSpawn(command, args, opts = {}, extra = {}) {
		return new SpawnPromise(command, args, opts, extra);
		}
		//# sourceMappingURL=index.js.map

-1

dist/index.js.map

@vltpkg/promise-spawn - npm Package Compare versions

New alerts

Worsened metrics

Dependency changes