validate-npm-package-name-cli 1.0.0 → 2.0.0

package/.nycrc

@@ -0,0 +1,12 @@
+{
+	"all": true,
+	"reporter": [
+		"html",
+		"text",
+		"lcov"
+	],
+	"exclude": [
+		"coverage",
+		"test"
+	]
+}

package/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v2.0.0](https://github.com/ljharb/validate-npm-package-name-cli/compare/v1.0.0...v2.0.0) - 2025-10-31
+
+### Commits
+
+- [Refactor] use `pargs` package [`3a8ba69`](https://github.com/ljharb/validate-npm-package-name-cli/commit/3a8ba69027be1e45fafccb67367183d7341c6f8f)
+- [Tests] extract coverage config to file [`9930ba4`](https://github.com/ljharb/validate-npm-package-name-cli/commit/9930ba4d1b2f79009d73e08acda5dc9a1f021a62)
+- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/eslint-config`, `@ljharb/tsconfig`, `@types/node`, `undici-types` [`82aa998`](https://github.com/ljharb/validate-npm-package-name-cli/commit/82aa99819d87b78c0ec1a28b40ff3c971451ef5a)
+- [Breaking] update `engines.node` [`bcaddc4`](https://github.com/ljharb/validate-npm-package-name-cli/commit/bcaddc45999755d95026b473c900c495830ee418)
+- [Deps] update `validate-npm-package-name` [`5557a25`](https://github.com/ljharb/validate-npm-package-name-cli/commit/5557a25fc1e046efe00569c90de4282fee79449e)
+
 ## v1.0.0 - 2025-02-26
 
 ### Commits

package/bin.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 import { styleText } from 'util';
-import pargs from './pargs.mjs';
+import pargs from 'pargs';
 
 const {
-	positionals: [packageName],
 	help,
+	positionals: [packageName],
 } = await pargs(import.meta.filename, {
 	allowPositionals: 1,
 	minPositionals: 1,
@@ -18,14 +18,14 @@ import validate from 'validate-npm-package-name';
 const {
 	validForNewPackages,
 	warnings,
-	errors,
+	errors: validateErrors,
 } = validate(packageName);
 
 if (validForNewPackages) {
 	console.log(styleText('green', packageName));
 } else {
 	warnings?.forEach((warning) => console.warn(styleText('yellow', warning)));
-	errors?.forEach((error) => console.error(styleText('red', error)));
+	validateErrors?.forEach((error) => console.error(styleText('red', error)));
 
 	process.exitCode = 1;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "validate-npm-package-name-cli",
-	"version": "1.0.0",
+	"version": "2.0.0",
 	"description": "CLI for npmjs.com/validate-npm-package-name - give me a string and I'll tell you if it's a valid npm package name",
 	"bin": "./bin.mjs",
 	"main": false,
@@ -40,13 +40,14 @@
 	},
 	"homepage": "https://github.com/ljharb/validate-npm-package-name-cli#readme",
 	"dependencies": {
-		"validate-npm-package-name": "^6.0.0"
+		"pargs": "1.1",
+		"validate-npm-package-name": "^6.0.2"
 	},
 	"devDependencies": {
-		"@arethetypeswrong/cli": "^0.17.4",
-		"@ljharb/eslint-config": "^21.1.1",
-		"@ljharb/tsconfig": "^0.2.3",
-		"@types/node": "^22.13.5",
+		"@arethetypeswrong/cli": "^0.18.2",
+		"@ljharb/eslint-config": "^21.2.0",
+		"@ljharb/tsconfig": "^0.3.2",
+		"@types/node": "^22.18.13",
 		"@types/tape": "^5.8.1",
 		"@types/validate-npm-package-name": "^4.0.2",
 		"auto-changelog": "^2.5.0",
@@ -57,23 +58,10 @@
 		"safe-publish-latest": "^2.0.0",
 		"tape": "^5.9.0",
 		"typescript": "next",
-		"undici-types": "^7.3.0"
+		"undici-types": "^7.16.0"
 	},
 	"engines": {
-		"node": "^22.14 || >= 23.9"
-	},
-	"c8": {
-		"all": true,
-		"reporter": [
-			"html",
-			"text",
-			"lcov"
-		],
-		"exclude": [
-			"coverage",
-			"test",
-			"pargs.mjs"
-		]
+		"node": "^22.20 || ^24.10 || >= 25"
 	},
 	"auto-changelog": {
 		"output": "CHANGELOG.md",

package/pargs.d.mts

@@ -1,65 +0,0 @@
-export type ExtractIterable<T> = T extends Iterable<infer U> ? U : never;
-
-// export type GroupedByString<T> = { [k: string]: null | T[] };
-
-// declare function groupByString<T>(iterable: Iterable<T>, cb: (item: T) => string): GroupedByString<T>;
-
-import { parseArgs, type ParseArgsConfig as PAC } from "util";
-
-export type ParseArgsConfig = PAC;
-
-type ParseArgsOptionsConfig = NonNullable<ParseArgsConfig['options']>;
-
-type ParseArgsOptionConfig = ParseArgsOptionsConfig[keyof ParseArgsOptionsConfig];
-
-export type PargsConfig = Omit<ParseArgsConfig, 'args' | 'strict' | 'allowPositionals' | 'options'> & {
-    options?: {
-        [longOption: string]: ParseArgsOptionConfig | (Omit<ParseArgsOptionConfig, 'type'> & {
-            type: 'enum';
-            choices: string[];
-        });
-    };
-    allowPositionals?: boolean | number;
-    minPositionals?: number;
-};
-
-export type PargsRootConfig = PargsConfig & {
-    subcommands: Record<string, PargsConfig>
-};
-
-export type ParseArgsError = (Error | TypeError) & {
-    code:
-        | 'ERR_PARSE_ARGS_UNKNOWN_OPTION'
-        | 'ERR_PARSE_ARGS_INVALID_OPTION_VALUE'
-        | 'ERR_INVALID_ARG_TYPE'
-        | 'ERR_INVALID_ARG_VALUE'
-        | 'ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL'
-};
-
-export type OptionToken = Extract<
-    NonNullable<
-        ReturnType<typeof parseArgs>['tokens']
-    >[number],
-    { kind: 'option' }
->;
-
-export type PargsParsed<T extends (PargsConfig | PargsRootConfig)> = (
-    T extends PargsRootConfig ? {
-        command: { name: keyof T['subcommands'] } & PargsParsed<PargsConfig>,
-    } : {}
-) & {
-    errors: string[],
-    help(): Promise<void>,
-} & ReturnType<typeof parseArgs>;
-
-// declare function pargs<C extends PargsRootConfig>(
-//     entrypointPath: ImportMeta['filename'],
-//     obj: C,
-// ): Promise<PargsParsed<C>>;
-
-declare function pargs<C extends PargsRootConfig | PargsConfig>(
-    entrypointPath: ImportMeta['filename'],
-    obj: C,
-): Promise<PargsParsed<C>>;
-
-export default pargs;

package/pargs.mjs

@@ -1,217 +0,0 @@
-import { parseArgs } from 'util';
-import { dirname, join } from 'path';
-import { realpathSync } from 'fs';
-import { readFile } from 'fs/promises';
-
-const { hasOwn } = Object;
-
-/** @type {(e: unknown) => e is import('./pargs.mjs').ParseArgsError} */
-function isParseArgsError(e) {
-	return !!e
-		&& typeof e === 'object'
-		&& 'code' in e
-		&& (
-			e.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION'
-			|| e.code === 'ERR_PARSE_ARGS_INVALID_OPTION_VALUE'
-			|| e.code === 'ERR_INVALID_ARG_TYPE'
-			|| e.code === 'ERR_INVALID_ARG_VALUE'
-			|| e.code === 'ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL'
-		);
-}
-
-/* eslint max-lines-per-function: 0, max-statements: 0, complexity: 0, sort-keys: 0, no-magic-numbers: 0 */
-
-/** @type {import('./pargs.mjs').default} */
-export default async function pargs(entrypointPath, obj) {
-	const argv = process.argv.flatMap((arg) => {
-		try {
-			const realpathedArg = realpathSync(arg);
-			if (
-				realpathedArg === process.execPath
-				|| realpathedArg === entrypointPath
-			) {
-				return [];
-			}
-		} catch (e) { /**/ }
-		return arg;
-	});
-
-	if ('help' in obj || (obj.options && 'help' in obj.options)) {
-		throw new TypeError('The "help" option is reserved');
-	}
-
-	/** @type {string[]} */
-	const errors = [];
-
-	if ('subcommands' in obj && (!obj.subcommands || typeof obj.subcommands !== 'object')) {
-		throw new TypeError('Error: `subcommands` must be an object');
-	}
-
-	const { subcommands, ...passedConfig } = obj;
-
-	if ('subcommands' in obj && Object.keys(obj.subcommands).length === 0) {
-		throw new TypeError('Error: `subcommands` must be an object with at least one key');
-	}
-
-	if ('subcommands' in obj && 'allowPositionals' in passedConfig) {
-		throw new TypeError('Error: `allowPositionals` is not allowed when `subcommands` is defined');
-	}
-
-	const enums = { __proto__: null };
-
-	/** @type {{ options: import('./pargs.mjs').ParseArgsConfig['options'] & { help: { default: false, type: 'boolean' } } }} */
-	const normalizedOptions = Object.fromEntries(Object.entries(passedConfig.options ?? {}).flatMap(([key, value]) => {
-		if (value.type !== 'enum') {
-			return [[key, value]];
-		}
-
-		if (!Array.isArray(value.choices) || !value.choices.every((x) => typeof x === 'string')) {
-			throw new TypeError(`Error: enum choices must be an array of strings; \`${key}\` is invalid`);
-		}
-
-		enums[key] = value;
-		return [[key, { ...value, type: 'string' }]];
-	}).concat([
-		[
-			'help',
-			{
-				default: false,
-				type: 'boolean',
-			},
-		],
-	]));
-
-	/** @type {import('./pargs.mjs').ParseArgsConfig & { tokens: true, allowNegative: true, strict: true, options: typeof normalizedOptions }} */
-	const newObj = {
-		args: subcommands ? argv.slice(0, 1) : argv,
-		...passedConfig,
-		options: normalizedOptions,
-		tokens: true,
-		allowNegative: true,
-		allowPositionals: !!subcommands || typeof passedConfig.allowPositionals !== 'undefined',
-		minPositionals: 0,
-		strict: true,
-	};
-
-	// console.log(newObj.options);
-
-	try {
-		const { tokens, ...results } = parseArgs(newObj);
-
-		const enumEntries = Object.entries(enums);
-		if (enumEntries.length > 0) {
-			enumEntries.forEach(([key, config]) => {
-				const value = results.values[key];
-				// console.log(key, config, value);
-
-				if (!config.choices.includes(value)) {
-					errors.push(`Error: Invalid value for option "${key}"`);
-				}
-			});
-		}
-
-		// eslint-disable-next-line no-inner-declarations
-		async function help() {
-			if (('help' in results.values && results.values.help) || errors.length > 0) {
-				const helpText = await `${await readFile(join(dirname(entrypointPath), './help.txt'), 'utf-8')}`;
-				if (errors.length === 0) {
-					console.log(helpText);
-				} else {
-					console.error(`${helpText}${errors.length === 0 ? '' : '\n'}`);
-
-					process.exitCode ||= parseInt('1'.repeat(errors.length), 2);
-					errors.forEach((error) => console.error(error));
-				}
-
-				process.exit();
-			}
-		}
-
-		const { allowPositionals, minPositionals } = passedConfig;
-
-		const posCount = typeof allowPositionals === 'number' ? allowPositionals : allowPositionals || subcommands ? Infinity : 0;
-		if (results.positionals.length > posCount) {
-			errors.push(`Only ${posCount} positional arguments allowed; got ${results.positionals.length}`);
-		}
-		if (!results.values.help && typeof minPositionals === 'number' && results.positionals.length < minPositionals) {
-			errors.push(`At least ${posCount} positional arguments are required; got ${results.positionals.length}`);
-		}
-
-		const optionTokens = tokens.filter(/** @type {(token: typeof tokens[number]) => token is import('./pargs.mjs').OptionToken} */ (token) => token.kind === 'option');
-
-		const bools = obj.options ? Object.entries(obj.options).filter(([, { type }]) => type === 'boolean') : [];
-		const boolMap = new Map(bools.concat([['help', newObj.options.help]]));
-		for (let i = 0; i < optionTokens.length; i += 1) {
-			const { name, value } = optionTokens[i];
-			if (boolMap.has(name) && typeof value !== 'boolean' && typeof value !== 'undefined') {
-				errors.push(`Error: Argument --${name} must be a boolean`);
-			}
-		}
-
-		const passedArgs = new Set(optionTokens.map(({ name, rawName }) => (rawName === '--no-help' ? rawName : name)));
-
-		const groups = Object.groupBy(passedArgs, (x) => x.replace(/^no-/, ''));
-		for (let i = 0; i < bools.length; i++) {
-			const [key] = bools[i];
-			if ((groups[key]?.length ?? 0) > 1) {
-				errors.push(`Error: Arguments \`--${key}\` and \`--no-${key}\` are mutually exclusive`);
-			}
-			if (passedArgs.has(`no-${key}`)) {
-				results.values[key] = !results.values[`no-${key}`];
-			}
-			delete results.values[`no-${key}`];
-		}
-
-		const knownOptions = Object.keys(newObj.options);
-		const unknownArgs = knownOptions.length > 0 ? passedArgs.difference(new Set(knownOptions)) : passedArgs;
-		if (unknownArgs.size > 0) {
-			errors.push(`Error: Unknown option(s): ${Array.from(unknownArgs, (x) => `\`${x}\``).join(', ')}`);
-		}
-
-		/** @type {undefined | import('./pargs.mjs').PargsParsed<import('./pargs.mjs').PargsConfig>} */
-		let command;
-		if (subcommands) {
-			const subcommand = argv[0];
-			// eslint-disable-next-line no-extra-parens
-			if (hasOwn(/** @type {object} */ (subcommands), subcommand)) {
-				process.argv.splice(process.argv.indexOf(subcommand), 1);
-				command = await pargs(entrypointPath, subcommands[subcommand]);
-			} else {
-				errors.push(`Error: unknown command "${command}"`);
-			}
-		}
-
-		return {
-			help,
-			errors,
-			...results,
-			...command && {
-				help: ('help' in command && command.help) || help,
-				command: {
-					name: argv[0],
-					...command,
-				},
-			},
-			...obj.tokens && { tokens },
-		};
-	} catch (e) {
-		const fakeErrors = [`Error: ${!!e && typeof e === 'object' && 'message' in e && e.message}`];
-		if (isParseArgsError(e)) {
-			return {
-				async help() {
-					const helpText = await `${await readFile(join(dirname(entrypointPath), './help.txt'), 'utf-8')}`;
-					console.error(`${helpText}'\n`);
-
-					process.exitCode ||= parseInt('1', 2);
-					console.error(fakeErrors[0]);
-
-					process.exit();
-				},
-				values: {},
-				positionals: [],
-				errors: fakeErrors,
-			};
-		}
-		throw e;
-	}
-}