Require Node.js 20

Author: sindresorhus

.github/workflows/main.yml

@@ -10,12 +10,11 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
-          - 21
+          - 24
           - 20
-          - 18
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install

package.json

@@ -17,7 +17,7 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=18"
+		"node": ">=20"
 	},
 	"scripts": {
 		"prepare": "npm run build",
@@ -60,39 +60,41 @@
 		"yargs-parser"
 	],
 	"devDependencies": {
-		"@rollup/plugin-commonjs": "^25.0.7",
+		"@rollup/plugin-commonjs": "^28.0.6",
 		"@rollup/plugin-json": "^6.1.0",
-		"@rollup/plugin-node-resolve": "^15.2.3",
+		"@rollup/plugin-node-resolve": "^16.0.1",
+		"@sindresorhus/tsconfig": "^8.0.1",
 		"@types/minimist": "^1.2.5",
-		"ava": "^6.1.1",
-		"camelcase-keys": "^9.1.3",
+		"ava": "^6.4.1",
+		"camelcase-keys": "^10.0.0",
 		"common-tags": "^2.0.0-alpha.1",
-		"decamelize": "^6.0.0",
+		"decamelize": "^6.0.1",
 		"decamelize-keys": "^2.0.1",
 		"delete_comments": "^0.0.2",
-		"execa": "^8.0.1",
-		"globby": "^14.0.1",
+		"execa": "^9.6.0",
+		"globby": "^14.1.0",
 		"indent-string": "^5.0.0",
 		"minimist-options": "4.1.0",
-		"normalize-package-data": "^6.0.0",
+		"normalize-package-data": "^8.0.0",
 		"read-package-up": "^11.0.0",
 		"read-pkg": "^9.0.1",
 		"redent": "^4.0.0",
-		"rollup": "^4.12.0",
-		"rollup-plugin-dts": "^6.1.0",
-		"rollup-plugin-license": "^3.2.0",
+		"rollup": "^4.50.2",
+		"rollup-plugin-dts": "^6.2.3",
+		"rollup-plugin-license": "^3.6.0",
 		"stack-utils": "^2.0.6",
 		"trim-newlines": "^5.0.0",
-		"tsd": "^0.30.7",
-		"type-fest": "^4.10.3",
-		"typescript": "~5.3.3",
-		"xo": "^0.57.0",
-		"yargs-parser": "^21.1.1"
+		"tsd": "^0.33.0",
+		"type-fest": "^5.0.0",
+		"typescript": "~5.9.2",
+		"xo": "^1.2.2",
+		"yargs-parser": "^22.0.0"
 	},
 	"xo": {
 		"rules": {
 			"unicorn/no-process-exit": "off",
-			"unicorn/error-message": "off"
+			"unicorn/error-message": "off",
+			"@typescript-eslint/no-unsafe-call": "off"
 		},
 		"ignores": [
 			"build"

readme.md

@@ -213,6 +213,8 @@ Infer the argument type.
 
 By default, the argument `5` in `$ foo 5` becomes a string. Enabling this would infer it as a number.
 
+Also applies to flags without explicit types. By default, `--count 42` remains as the string `'42'`. With `inferType: true`, it becomes the number `42`.
+
 ##### booleanDefault
 
 Type: `boolean | undefined`\

rollup.config.js

@@ -84,5 +84,5 @@ const dtsConfig = defineConfig({
 	],
 });
 
-// eslint-disable-next-line import/no-anonymous-default-export
+// eslint-disable-next-line import-x/no-anonymous-default-export
 export default [config, dtsConfig];

source/index.d.ts

@@ -291,15 +291,6 @@ export type Options<Flags extends AnyFlags> = {
 	*/
 	readonly booleanDefault?: boolean | undefined;
 
-	// TODO: Remove this in meow 14.
-	/**
-	Whether to use [hard-rejection](https://github.com/sindresorhus/hard-rejection) or not. Disabling this can be useful if you need to handle `process.on('unhandledRejection')` yourself.
-
-	@deprecated This is the default behavior since Node.js 16, so this option is moot.
-	@default true
-	*/
-	readonly hardRejection?: boolean;
-
 	/**
 	Whether to allow unknown flags or not.
 

source/options.js

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import {dirname} from 'node:path';
+import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {readPackageUpSync} from 'read-package-up';
 import normalizePackageData from 'normalize-package-data';
@@ -65,11 +65,10 @@ export const buildOptions = (helpText, options) => {
 	}
 
 	const foundPackage = options.pkg ?? readPackageUpSync({
-		cwd: dirname(fileURLToPath(options.importMeta.url)),
+		cwd: path.dirname(fileURLToPath(options.importMeta.url)),
 		normalize: false,
 	})?.packageJson;
 
-	// eslint-disable-next-line unicorn/prevent-abbreviations
 	const pkg = foundPackage ?? {};
 	normalizePackageData(pkg);
 

test-d/index.ts

@@ -1,131 +1,64 @@
 import {expectAssignable, expectError, expectType} from 'tsd';
 import type {PackageJson} from 'type-fest';
-import meow, {type Result} from '../source/index.js';
+import meow from '../source/index.js';
 
 type AnyFlag = NonNullable<NonNullable<Parameters<typeof meow>[0]>['flags']>[string];
 
 const importMeta = import.meta;
 
+// Missing importMeta should error
 expectError(meow('Help text'));
 expectError(meow('Help text', {}));
-expectType<Result<never>>(meow('Help text', {importMeta, hardRejection: false}));
-expectAssignable<{flags: {foo: number}}>(
-	meow({importMeta: import.meta, flags: {foo: {type: 'number', isRequired: true}}}),
-);
-expectAssignable<{flags: {foo: string}}>(
-	meow({importMeta, flags: {foo: {type: 'string', isRequired: true}}}),
-);
-expectAssignable<{flags: {foo: boolean}}>(
-	meow({importMeta, flags: {foo: {type: 'boolean', isRequired: true}}}),
-);
-expectAssignable<{flags: {foo: number | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'number'}}}),
-);
-expectAssignable<{flags: {foo: string | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'string'}}}),
-);
-expectAssignable<{flags: {foo: boolean | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'boolean'}}}),
-);
-expectAssignable<{flags: {foo: number[] | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'number', isMultiple: true}}}),
-);
-expectAssignable<{flags: {foo: string[] | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'string', isMultiple: true}}}),
-);
-expectAssignable<{flags: {foo: boolean[] | undefined}}>(
-	meow({importMeta, flags: {foo: {type: 'boolean', isMultiple: true}}}),
-);
-expectType<Result<never>>(meow({importMeta, description: 'foo'}));
-expectType<Result<never>>(meow({importMeta, description: false}));
-expectType<Result<never>>(meow({importMeta, help: 'foo'}));
-expectType<Result<never>>(meow({importMeta, help: false}));
-expectType<Result<never>>(meow({importMeta, version: 'foo'}));
-expectType<Result<never>>(meow({importMeta, autoHelp: false}));
-expectType<Result<never>>(meow({importMeta, autoVersion: false}));
-expectType<Result<never>>(meow({importMeta, pkg: {foo: 'bar'}}));
-expectType<Result<never>>(meow({importMeta, argv: ['foo', 'bar']}));
-expectType<Result<never>>(meow({importMeta, inferType: true}));
-expectType<Result<never>>(meow({importMeta, booleanDefault: true}));
-expectType<Result<never>>(meow({importMeta, booleanDefault: undefined}));
-expectType<Result<never>>(meow({importMeta, hardRejection: false}));
 
+// Flag types
+expectAssignable<{flags: {foo: number}}>(meow({importMeta, flags: {foo: {type: 'number', isRequired: true}}}));
+expectAssignable<{flags: {foo: string | undefined}}>(meow({importMeta, flags: {foo: {type: 'string'}}}));
+expectAssignable<{flags: {foo: boolean[] | undefined}}>(meow({importMeta, flags: {foo: {type: 'boolean', isMultiple: true}}}));
+
+// Complete result test
 const result = meow('Help text', {
 	importMeta,
 	flags: {
 		foo: {type: 'boolean', shortFlag: 'f'},
-		'foo-bar': {type: 'number', aliases: ['foobar', 'fooBar']},
+		'foo-bar': {type: 'number', aliases: ['foobar']},
 		bar: {type: 'string', default: ''},
 		abc: {type: 'string', isMultiple: true},
-		baz: {type: 'string', choices: ['rainbow', 'cat', 'unicorn']},
+		baz: {type: 'string', choices: ['rainbow', 'cat']},
 	},
 });
 
 expectType<string[]>(result.input);
 expectType<PackageJson>(result.pkg);
 expectType<string>(result.help);
-
 expectType<boolean | undefined>(result.flags.foo);
 expectType<number | undefined>(result.flags.fooBar);
 expectType<string>(result.flags.bar);
 expectType<string[] | undefined>(result.flags.abc);
 expectType<string | undefined>(result.flags.baz);
-expectType<boolean | undefined>(result.unnormalizedFlags.foo);
-expectType<unknown>(result.unnormalizedFlags.f);
-expectType<number | undefined>(result.unnormalizedFlags['foo-bar']);
-expectType<unknown>(result.unnormalizedFlags.foobar);
-expectType<unknown>(result.unnormalizedFlags.fooBar);
-expectType<string>(result.unnormalizedFlags.bar);
-expectType<string[] | undefined>(result.unnormalizedFlags.abc);
-expectType<string | undefined>(result.unnormalizedFlags.baz);
 
 result.showHelp();
 result.showHelp(1);
 result.showVersion();
 
+// Const assertion
 const options = {
 	importMeta,
 	flags: {
-		rainbow: {
-			type: 'boolean',
-			shortFlag: 'r',
-		},
+		rainbow: {type: 'boolean', shortFlag: 'r'},
 	},
 } as const;
 
 meow('', options);
 
+// Flag validation - defaults
 expectAssignable<AnyFlag>({type: 'string', default: 'cat'});
 expectAssignable<AnyFlag>({type: 'number', default: 42});
-expectAssignable<AnyFlag>({type: 'boolean', default: true});
-
-expectAssignable<AnyFlag>({type: 'string', default: undefined});
-expectAssignable<AnyFlag>({type: 'number', default: undefined});
-expectAssignable<AnyFlag>({type: 'boolean', default: undefined});
-
 expectAssignable<AnyFlag>({type: 'string', isMultiple: true, default: ['cat']});
-expectAssignable<AnyFlag>({type: 'number', isMultiple: true, default: [42]});
-expectAssignable<AnyFlag>({type: 'boolean', isMultiple: true, default: [false]});
-
 expectError<AnyFlag>({type: 'string', isMultiple: true, default: 'cat'});
-expectError<AnyFlag>({type: 'number', isMultiple: true, default: 42});
-expectError<AnyFlag>({type: 'boolean', isMultiple: true, default: false});
 
+// Flag validation - choices
 expectAssignable<AnyFlag>({type: 'string', choices: ['cat', 'unicorn']});
-expectAssignable<AnyFlag>({type: 'number', choices: [1, 2]});
-expectAssignable<AnyFlag>({type: 'boolean', choices: [true, false]});
-expectAssignable<AnyFlag>({type: 'string', isMultiple: true, choices: ['cat']});
-expectAssignable<AnyFlag>({type: 'string', isMultiple: false, choices: ['cat']});
-
+expectAssignable<AnyFlag>({choices: ['cat']});
 expectError<AnyFlag>({type: 'string', choices: 'cat'});
-expectError<AnyFlag>({type: 'number', choices: 1});
-expectError<AnyFlag>({type: 'boolean', choices: true});
-
 expectError<AnyFlag>({type: 'string', choices: [1]});
-expectError<AnyFlag>({type: 'number', choices: ['cat']});
-expectError<AnyFlag>({type: 'boolean', choices: ['cat']});
-
-expectAssignable<AnyFlag>({choices: ['cat']});
-expectAssignable<AnyFlag>({choices: [1]});
-expectAssignable<AnyFlag>({choices: [true]});
 expectError<AnyFlag>({choices: ['cat', 1, true]});

test/_utils.js

@@ -35,36 +35,34 @@ const stackUtils = new StackUtils();
 
 export const stackToErrorMessage = stack => stackUtils.clean(stack).split('\n').at(0);
 
-export const _verifyCli = (baseFixture = defaultFixture) => test.macro(
-	async (t, {fixture = baseFixture, args, execaOptions, expected, error}) => {
-		const assertions = await t.try(async tt => {
-			const arguments_ = args ? args.split(' ') : [];
-			const {all: output, exitCode} = await spawnFixture(fixture, arguments_, {reject: false, all: true, ...execaOptions});
-			tt.log('args:', arguments_);
+export const _verifyCli = (baseFixture = defaultFixture) => test.macro(async (t, {fixture = baseFixture, args, execaOptions, expected, error}) => {
+	const assertions = await t.try(async tt => {
+		const arguments_ = args ? args.split(' ') : [];
+		const {all: output, exitCode} = await spawnFixture(fixture, arguments_, {reject: false, all: true, ...execaOptions});
+		tt.log('args:', arguments_);
 
-			if (error) {
-				tt.log(`error (code ${exitCode}):\n`, output);
+		if (error) {
+			tt.log(`error (code ${exitCode}):\n`, output);
 
-				if (typeof error === 'string') {
-					tt.is(output, error);
-					tt.is(exitCode, 2);
-				} else {
-					const error_ = error.clean ? stackToErrorMessage(output) : output;
-
-					tt.is(error_, error.message);
-					tt.is(exitCode, error.code);
-				}
+			if (typeof error === 'string') {
+				tt.is(output, error);
+				tt.is(exitCode, 2);
 			} else {
-				tt.log('output:\n', output);
+				const error_ = error.clean ? stackToErrorMessage(output) : output;
 
-				if (expected) {
-					tt.is(output, expected);
-				} else {
-					tt.pass();
-				}
+				tt.is(error_, error.message);
+				tt.is(exitCode, error.code);
 			}
-		});
+		} else {
+			tt.log('output:\n', output);
 
-		assertions.commit({retainLogs: !assertions.passed});
-	},
-);
+			if (expected) {
+				tt.is(output, expected);
+			} else {
+				tt.pass();
+			}
+		}
+	});
+
+	assertions.commit({retainLogs: !assertions.passed});
+});

test/fixtures/required/fixture-required-function.js

@@ -24,8 +24,7 @@ const cli = meow({
 		shouldError: {
 			type: 'boolean',
 			isRequired: (flags, _) =>
-				flags.allowError ? 'should error' : false
-			,
+				flags.allowError ? 'should error' : false,
 		},
 	},
 });

test/options/pkg.js

@@ -20,8 +20,6 @@ test('description', t => {
 	`);
 });
 
-test.todo('version');
-
 test('overriding pkg still normalizes', t => {
 	const cli = meow({
 		importMeta,
@@ -37,8 +35,6 @@ test('overriding pkg still normalizes', t => {
 			version: '',
 		},
 	});
-
-	// TODO: test that showVersion logs undefined
 });
 
 test('process title - bin default', verifyPackage, {