			'use strict';
			const os = require('os');
			const onExit = require('signal-exit');

			const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;

			// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
			const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
			const killResult = kill(signal);
			setKillTimeout(kill, signal, options, killResult);
			return killResult;
			};

			const setKillTimeout = (kill, signal, options, killResult) => {
			if (!shouldForceKill(signal, options, killResult)) {
			return;
			}

			const timeout = getForceKillAfterTimeout(options);
			const t = setTimeout(() => {
			kill('SIGKILL');
			}, timeout);

			// Guarded because there's no `.unref()` when `execa` is used in the renderer
			// process in Electron. This cannot be tested since we don't run tests in
			// Electron.
			// istanbul ignore else
			if (t.unref) {
			t.unref();
			}
			};

			const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
			return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
			};

			const isSigterm = signal => {
			return signal === os.constants.signals.SIGTERM \|\|
			(typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
			};

			const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
			if (forceKillAfterTimeout === true) {
			return DEFAULT_FORCE_KILL_TIMEOUT;
			}

			if (!Number.isFinite(forceKillAfterTimeout) \|\| forceKillAfterTimeout < 0) {
			throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
			}

			return forceKillAfterTimeout;
			};

			// `childProcess.cancel()`
			const spawnedCancel = (spawned, context) => {
			const killResult = spawned.kill();

			if (killResult) {
			context.isCanceled = true;
			}
			};

			const timeoutKill = (spawned, signal, reject) => {
			spawned.kill(signal);
			reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
			};

			// `timeout` option handling
			const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
			if (timeout === 0 \|\| timeout === undefined) {
			return spawnedPromise;
			}

			if (!Number.isFinite(timeout) \|\| timeout < 0) {
			throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
			}

			let timeoutId;
			const timeoutPromise = new Promise((resolve, reject) => {
			timeoutId = setTimeout(() => {
			timeoutKill(spawned, killSignal, reject);
			}, timeout);
			});

			const safeSpawnedPromise = spawnedPromise.finally(() => {
			clearTimeout(timeoutId);
			});

			return Promise.race([timeoutPromise, safeSpawnedPromise]);
			};

			// `cleanup` option handling
			const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
			if (!cleanup \|\| detached) {
			return timedPromise;
			}

			const removeExitHandler = onExit(() => {
			spawned.kill();
			});

			return timedPromise.finally(() => {
			removeExitHandler();
			});
			};

			module.exports = {
			spawnedKill,
			spawnedCancel,
			setupTimeout,
			setExitHandler
			};

rOACCT/node_modules/execa/lib/kill.js
583449d99081paginated-inlines

kill.js
View Options

rOACCT/node_modules/execa/lib/kill.js583449d99081paginated-inlines

kill.jsView Options

rOACCT/node_modules/execa/lib/kill.js
583449d99081paginated-inlines

kill.js
View Options