Rename minimumWait option to wait and require Node.js 18 (#33)

thecodedrift · web-flow · commit 46baeec79afa · 2023-08-31T17:37:18.000+07:00
diff --git a/fixtures/async.js b/fixtures/async.js
@@ -26,7 +26,7 @@ asyncExitHook(
 		console.log('quux');
 	},
 	{
-		minimumWait: 200,
+		wait: 200,
 	},
 );
 
diff --git a/fixtures/signal.js b/fixtures/signal.js
@@ -7,7 +7,7 @@ exitHook(signal => {
 asyncExitHook(async signal => {
 	console.log(signal);
 }, {
-	minimumWait: 200,
+	wait: 200,
 });
 
 setInterval(() => {}, 1 << 30);
diff --git a/index.d.ts b/index.d.ts
@@ -53,15 +53,15 @@ import {asyncExitHook} from 'exit-hook';
 asyncExitHook(() => {
 	console.log('Exiting');
 }, {
-	minimumWait: 500
+	wait: 500
 });
 
 throw new Error('🦄');
 
 //=> 'Exiting'
 
 // Removing an exit hook:
-const unsubscribe = asyncExitHook(() => {}, {minimumWait: 500});
+const unsubscribe = asyncExitHook(() => {}, {wait: 500});
 
 unsubscribe();
 ```
@@ -83,7 +83,7 @@ import {asyncExitHook, gracefulExit} from 'exit-hook';
 asyncExitHook(() => {
 	console.log('Exiting');
 }, {
-	minimumWait: 500
+	wait: 500
 });
 
 // Instead of `process.exit()`
@@ -94,7 +94,7 @@ export function gracefulExit(signal?: number): void;
 
 export interface Options {
 	/**
-	The amount of time in milliseconds that the `onExit` function is expected to take.
+	The amount of time in milliseconds that the `onExit` function is expected to take. When multiple async handlers are registered, the longest `wait` time will be used.
 	*/
-	minimumWait: number;
+	wait: number;
 }
diff --git a/index.js b/index.js
@@ -58,8 +58,8 @@ async function exit(shouldManuallyExit, isSynchronous, signal) {
 }
 
 function addHook(options) {
-	const {onExit, minimumWait, isSynchronous} = options;
-	const asyncCallbackConfig = [onExit, minimumWait];
+	const {onExit, wait, isSynchronous} = options;
+	const asyncCallbackConfig = [onExit, wait];
 
 	if (isSynchronous) {
 		callbacks.add(onExit);
@@ -116,13 +116,13 @@ export function asyncExitHook(onExit, options = {}) {
 		throw new TypeError('onExit must be a function');
 	}
 
-	if (!(typeof options.minimumWait === 'number' && options.minimumWait > 0)) {
-		throw new TypeError('minimumWait must be set to a positive numeric value');
+	if (!(typeof options.wait === 'number' && options.wait > 0)) {
+		throw new TypeError('wait must be set to a positive numeric value');
 	}
 
 	return addHook({
 		onExit,
-		minimumWait: options.minimumWait,
+		wait: options.wait,
 		isSynchronous: false,
 	});
 }
diff --git a/index.test-d.ts b/index.test-d.ts
@@ -4,7 +4,7 @@ import exitHook, {asyncExitHook} from './index.js';
 const unsubscribe = exitHook(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
 
 const asyncUnsubscribe = asyncExitHook(async () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
-	{minimumWait: 300},
+	{wait: 300},
 );
 
 expectType<() => void>(unsubscribe);
diff --git a/package.json b/package.json
@@ -13,7 +13,7 @@
 	"type": "module",
 	"exports": "./index.js",
 	"engines": {
-		"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+		"node": ">=18.0.0"
 	},
 	"scripts": {
 		"test": "xo && ava && tsd"
diff --git a/readme.md b/readme.md
@@ -74,19 +74,19 @@ The callback function to execute when the process exits via `gracefulExit`, and
 
 Type: `object`
 
-##### minimumWait
+##### wait
 
 Type: `number`
 
-The amount of time in milliseconds that the `onExit` function is expected to take.
+The amount of time in milliseconds that the `onExit` function is expected to take. When multiple async handlers are registered, the longest `wait` time will be used.
 
 ```js
 import {asyncExitHook} from 'exit-hook';
 
 asyncExitHook(async () => {
 	console.log('Exiting');
 }, {
-	minimumWait: 300
+	wait: 300
 });
 
 throw new Error('🦄');
@@ -102,7 +102,7 @@ import {asyncExitHook} from 'exit-hook';
 const unsubscribe = asyncExitHook(async () => {
 	console.log('Exiting');
 }, {
-	minimumWait: 300
+	wait: 300
 });
 
 unsubscribe();
@@ -135,4 +135,4 @@ Node.js does not offer an asynchronous shutdown API by default [#1](https://gith
 
 If you have asynchronous hooks registered and your Node.js process is terminated in a synchronous manner, a `SYNCHRONOUS TERMINATION NOTICE` error will be logged to the console. To avoid this, ensure you're only exiting via `gracefulExit` or that an upstream process manager is sending a `SIGINT` or `SIGTERM` signal to Node.js.
 
-Asynchronous hooks should make a "best effort" to perform their tasks within the `minimumWait` time, but also be written to assume they may not complete their tasks before termination.
+Asynchronous hooks should make a "best effort" to perform their tasks within the `wait` time, but also be written to assume they may not complete their tasks before termination.
diff --git a/test.js b/test.js
@@ -58,7 +58,7 @@ test('listener count', t => {
 	const unsubscribe4 = asyncExitHook(
 		async () => {},
 		{
-			minimumWait: 100,
+			wait: 100,
 		},
 	);
 	t.is(process.listenerCount('exit'), 1);
@@ -77,13 +77,18 @@ test('type enforcing', t => {
 	// Non-function passed to `asyncExitHook`.
 	t.throws(() => {
 		asyncExitHook(null, {
-			minimumWait: 100,
+			wait: 100,
 		});
 	}, {
 		instanceOf: TypeError,
 	});
 
-	// Non-numeric passed to `minimumWait` option.
+	// Non-numeric passed to `wait` option.
+	t.throws(() => {
+		asyncExitHook(async () => true, {wait: 'abc'});
+	});
+
+	// Empty value passed to `wait` option.
 	t.throws(() => {
 		asyncExitHook(async () => true, {});
 	});

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ asyncExitHook(`
`26`	`26`	`console.log('quux');`
`27`	`27`	`},`
`28`	`28`	`{`
`29`		`- minimumWait: 200,`
	`29`	`+ wait: 200,`
`30`	`30`	`},`
`31`	`31`	`);`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,8 @@ async function exit(shouldManuallyExit, isSynchronous, signal) {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`function addHook(options) {`
`61`		`- const {onExit, minimumWait, isSynchronous} = options;`
`62`		`- const asyncCallbackConfig = [onExit, minimumWait];`
	`61`	`+ const {onExit, wait, isSynchronous} = options;`
	`62`	`+ const asyncCallbackConfig = [onExit, wait];`
`63`	`63`
`64`	`64`	`if (isSynchronous) {`
`65`	`65`	`callbacks.add(onExit);`
`@@ -116,13 +116,13 @@ export function asyncExitHook(onExit, options = {}) {`
`116`	`116`	`throw new TypeError('onExit must be a function');`
`117`	`117`	`}`
`118`	`118`
`119`		`- if (!(typeof options.minimumWait === 'number' && options.minimumWait > 0)) {`
`120`		`- throw new TypeError('minimumWait must be set to a positive numeric value');`
	`119`	`+ if (!(typeof options.wait === 'number' && options.wait > 0)) {`
	`120`	`+ throw new TypeError('wait must be set to a positive numeric value');`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`return addHook({`
`124`	`124`	`onExit,`
`125`		`- minimumWait: options.minimumWait,`
	`125`	`+ wait: options.wait,`
`126`	`126`	`isSynchronous: false,`
`127`	`127`	`});`
`128`	`128`	`}`