Add isMultiple option for flags

.gitignore

@@ -1,2 +1,3 @@
 node_modules
 yarn.lock
+.vscode

index.d.ts

@@ -7,6 +7,7 @@ declare namespace meow {
 		readonly type?: Type;
 		readonly alias?: string;
 		readonly default?: Default;
+		readonly multiple?: boolean;
 	}
 
 	type StringFlag = Flag<'string', string>;
@@ -24,14 +25,16 @@ declare namespace meow {
 		- `type`: Type of value. (Possible values: `string` `boolean` `number`)
 		- `alias`: Usually used to define a short flag alias.
 		- `default`: Default value when the flag is not specified.
+		- `multiple`: Indicates a flag can be set multiple times. Returns an array. (Default: false)
 
 		@example
 		```
 		flags: {
 			unicorn: {
 				type: 'string',
 				alias: 'u',
-				default: 'rainbow'
+				default: ['rainbow', 'cat'],
+				multiple: true
 			}
 		}
 		```

index.js

@@ -9,6 +9,7 @@ const redent = require('redent');
 const readPkgUp = require('read-pkg-up');
 const hardRejection = require('hard-rejection');
 const normalizePackageData = require('normalize-package-data');
+const arrify = require('arrify');
 
 // Prevent caching of this module so module.parent is always accurate
 delete require.cache[__filename];
@@ -26,6 +27,7 @@ const meow = (helpText, options) => {
 			normalize: false
 		}).packageJson || {},
 		argv: process.argv.slice(2),
+		flags: {},
 		inferType: false,
 		input: 'string',
 		help: helpText,
@@ -40,16 +42,27 @@ const meow = (helpText, options) => {
 		hardRejection();
 	}
 
-	const minimistFlags = options.flags && typeof options.booleanDefault !== 'undefined' ? Object.keys(options.flags).reduce(
-		(flags, flag) => {
-			if (flags[flag].type === 'boolean' && !Object.prototype.hasOwnProperty.call(flags[flag], 'default')) {
-				flags[flag].default = options.booleanDefault;
-			}
+	const minimistFlags = Object.entries(options.flags).reduce((flags, [flagKey, flagValue]) => {
+		const flag = {...flagValue};
+		const {booleanDefault} = options;
 
-			return flags;
-		},
-		options.flags
-	) : options.flags;
+		if (
+			typeof booleanDefault !== 'undefined' &&
+			flag.type === 'boolean' &&
+			!Object.prototype.hasOwnProperty.call(flag, 'default')
+		) {
+			flag.default = flag.multiple ? [booleanDefault] : booleanDefault;
+		}
+
+		if (flag.multiple) {
+			flag.type = 'array';
+			delete flag.multiple;
+		}
+
+		flags[flagKey] = flag;
+
+		return flags;
+	}, {});
 
 	let minimistOptions = {
 		arguments: options.input,
@@ -71,6 +84,13 @@ const meow = (helpText, options) => {
 		};
 	}
 
+	if (minimistOptions.array !== undefined) {
+		minimistOptions.array = arrify(minimistOptions.array).map(flagKey => ({
+			key: flagKey,
+			[options.flags[flagKey].type || 'string']: true
+		}));
+	}
+
 	const {pkg} = options;
 	const argv = yargs(options.argv, minimistOptions);
 	let help = redent(trimNewlines((options.help || '').replace(/\t+\n*$/, '')), 2);
@@ -112,10 +132,12 @@ const meow = (helpText, options) => {
 	const flags = camelcaseKeys(argv, {exclude: ['--', /^\w$/]});
 	const unnormalizedFlags = {...flags};
 
-	if (options.flags !== undefined) {
-		for (const flagValue of Object.values(options.flags)) {
-			delete flags[flagValue.alias];
+	for (const [flagKey, flagValue] of Object.entries(options.flags).filter(([key]) => key !== '--')) {
+		if (!flagValue.multiple && Array.isArray(flags[flagKey])) {
+			throw new Error(`Only one value allowed for --${flagKey}.`);
 		}
+
+		delete flags[flagValue.alias];
 	}
 
 	return {

index.test-d.ts

@@ -35,8 +35,8 @@ const result = meow('Help text', {
 		foo: {type: 'boolean', alias: 'f'},
 		'foo-bar': {type: 'number'},
 		bar: {type: 'string', default: ''}
-	}}
-);
+	}
+});
 
 expectType<string[]>(result.input);
 expectType<PackageJson>(result.pkg);

package.json

@@ -41,6 +41,7 @@
 	],
 	"dependencies": {
 		"@types/minimist": "^1.2.0",
+		"arrify": "^2.0.1",
 		"camelcase-keys": "^6.1.1",
 		"decamelize-keys": "^1.1.0",
 		"hard-rejection": "^2.0.0",

readme.md

@@ -97,6 +97,7 @@ The key is the flag name and the value is an object with any of:
 - `type`: Type of value. (Possible values: `string` `boolean` `number`)
 - `alias`: Usually used to define a short flag alias.
 - `default`: Default value when the flag is not specified.
+- `multiple`: Indicates a flag can be set multiple times. Returns an array. (Default: false)
 
 Example:
 
@@ -105,7 +106,8 @@ flags: {
 	unicorn: {
 		type: 'string',
 		alias: 'u',
-		default: 'rainbow'
+		default: ['rainbow', 'cat'],
+		multiple: true
 	}
 }
 ```

test.js

@@ -307,3 +307,146 @@ test('supports `number` flag type - throws on incorrect default value', t => {
 		});
 	});
 });
+
+test('multiple flag set once returns array', t => {
+	t.deepEqual(meow({
+		argv: ['--foo=bar'],
+		flags: {
+			foo: {
+				type: 'string',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: ['bar']
+	});
+});
+
+test('multiple flag set multiple times', t => {
+	t.deepEqual(meow({
+		argv: ['--foo=bar', '--foo=baz'],
+		flags: {
+			foo: {
+				type: 'string',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: ['bar', 'baz']
+	});
+});
+
+test('multiple flag with space separated values', t => {
+	t.deepEqual(meow({
+		argv: ['--foo', 'bar', 'baz'],
+		flags: {
+			foo: {
+				type: 'string',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: ['bar', 'baz']
+	});
+});
+
+test('single flag set more than once => throws', t => {
+	t.throws(() => {
+		meow({
+			argv: ['--foo=bar', '--foo=baz'],
+			flags: {
+				foo: {
+					type: 'string'
+				}
+			}
+		});
+	}, {message: 'Only one value allowed for --foo.'});
+});
+
+test('multiple boolean flag', t => {
+	t.deepEqual(meow({
+		argv: ['--foo', '--foo=false'],
+		flags: {
+			foo: {
+				type: 'boolean',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: [true, false]
+	});
+});
+
+test('multiple boolean flag is false by default', t => {
+	t.deepEqual(meow({
+		argv: [],
+		flags: {
+			foo: {
+				type: 'boolean',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: [false]
+	});
+});
+
+test('multiple flag with `booleanDefault: undefined` => filter out unset boolean args', t => {
+	t.deepEqual(meow({
+		argv: ['--foo'],
+		booleanDefault: undefined,
+		flags: {
+			foo: {
+				type: 'boolean',
+				multiple: true
+			},
+			bar: {
+				type: 'boolean',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: [true]
+	});
+});
+
+test('multiple number flag', t => {
+	t.deepEqual(meow({
+		argv: ['--foo=1.3', '--foo=-1'],
+		flags: {
+			foo: {
+				type: 'number',
+				multiple: true
+			}
+		}
+	}).flags, {
+		foo: [1.3, -1]
+	});
+});
+
+test('multiple flag default values', t => {
+	t.deepEqual(meow({
+		argv: [],
+		flags: {
+			string: {
+				type: 'string',
+				multiple: true,
+				default: ['foo']
+			},
+			boolean: {
+				type: 'boolean',
+				multiple: true,
+				default: [true]
+			},
+			number: {
+				type: 'number',
+				multiple: true,
+				default: [0.5]
+			}
+		}
+	}).flags, {
+		string: ['foo'],
+		boolean: [true],
+		number: [0.5]
+	});
+});