Parse negative values for numeric parser types

index.js

@@ -10,6 +10,16 @@ class ArgError extends Error {
 	}
 }
 
+function isNumericType(type) {
+	return (
+		type === Number ||
+		type === parseInt ||
+		type === parseFloat ||
+		// eslint-disable-next-line no-undef
+		(typeof BigInt !== 'undefined' && type === BigInt)
+	);
+}
+
 function arg(
 	opts,
 	{
@@ -59,19 +69,22 @@ function arg(
 
 		let type = opts[key];
 		let isFlag = false;
+		let isNumeric = false;
 
 		if (
 			Array.isArray(type) &&
 			type.length === 1 &&
 			typeof type[0] === 'function'
 		) {
 			const [fn] = type;
+			isNumeric = isNumericType(fn);
 			type = (value, name, prev = []) => {
 				prev.push(fn(value, name, prev[prev.length - 1]));
 				return prev;
 			};
 			isFlag = fn === Boolean || fn[flagSymbol] === true;
 		} else if (typeof type === 'function') {
+			isNumeric = isNumericType(type);
 			isFlag = type === Boolean || type[flagSymbol] === true;
 		} else {
 			throw new ArgError(
@@ -87,7 +100,7 @@ function arg(
 			);
 		}
 
-		handlers[key] = [type, isFlag];
+		handlers[key] = [type, isFlag, isNumeric];
 	}
 
 	for (let i = 0, len = argv.length; i < len; i++) {
@@ -136,7 +149,7 @@ function arg(
 					}
 				}
 
-				const [type, isFlag] = handlers[argName];
+				const [type, isFlag, isNumeric] = handlers[argName];
 
 				if (!isFlag && j + 1 < separatedArguments.length) {
 					throw new ArgError(
@@ -152,12 +165,7 @@ function arg(
 						argv.length < i + 2 ||
 						(argv[i + 1].length > 1 &&
 							argv[i + 1][0] === '-' &&
-							!(
-								argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) &&
-								(type === Number ||
-									// eslint-disable-next-line no-undef
-									(typeof BigInt !== 'undefined' && type === BigInt))
-							))
+							!(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && isNumeric))
 					) {
 						const extended =
 							originalArgName === argName ? '' : ` (alias for ${argName})`;

test.js

@@ -522,6 +522,62 @@ test('should parse negative numbers (separate argument form)', () => {
 	});
 });
 
+test('should parse negative numbers with parseInt', () => {
+	const argv = ['--int', '-100'];
+
+	const result = arg(
+		{
+			'--int': parseInt
+		},
+		{
+			argv
+		}
+	);
+
+	expect(result).to.deep.equal({
+		_: [],
+		'--int': -100
+	});
+});
+
+test('should parse negative numbers with parseFloat', () => {
+	const argv = ['--float', '-0.1'];
+
+	const result = arg(
+		{
+			'--float': parseFloat
+		},
+		{
+			argv
+		}
+	);
+
+	expect(result).to.deep.equal({
+		_: [],
+		'--float': -0.1
+	});
+});
+
+test('should parse negative numbers for numeric array types', () => {
+	const argv = ['--int', '-5', '--custom-int', '-10'];
+
+	const result = arg(
+		{
+			'--int': [Number],
+			'--custom-int': [parseInt]
+		},
+		{
+			argv
+		}
+	);
+
+	expect(result).to.deep.equal({
+		_: [],
+		'--int': [-5],
+		'--custom-int': [-10]
+	});
+});
+
 test('should error if numeric type is followed by non-negative, non-argument', () => {
 	const argv = ['--int', '-abc'];