@trenskow/arguments-parser 0.2.12 → 0.2.14

package/lib/index.js

@@ -17,19 +17,33 @@ plugins.use(() => ({
 	supportsType: () => true,
 	validatorsForType: () => ({
 		description: ['string'],
-		defaultDescription: ['string']
+		defaultDescription: ['string'],
+		secret: ['boolean'],
+		short: ['string'],
 	}),
 	validate: (data) => data,
 	formalize: (schema) => schema
 }));
 
-const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placeholder = '<>', command, strings = {} } = {}) => {
+const argumentsParser = (
+	{
+		args = process.argv.slice(2),
+		argvLevel = 0,
+		placeholder = '<>',
+		command,
+		strings = {},
+		help: {
+			usage: helpUsage,
+			options: helpOptions,
+		} = {}
+	} = {}
+) => {
 
 	const [ opening, closing ] = placeholder.split('');
 
 	const base = `${process.argv.slice(1, argvLevel + 2).map(((arg) => basename(arg))).join(' ')}`;
 
-	const list = (items) => {
+	const list = (print, items) => {
 
 		const maxLength = Object.keys(items)
 			.reduce((length, key) => Math.max(length, key.length), 0);
@@ -42,18 +56,49 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 
 	};
 
+	if (typeof helpUsage === 'undefined') {
+		helpUsage = [
+			strings?.help?.usage || 'Usage:',
+			base
+		];
+	}
+
+	const printHelp = (error) => {
+
+		print();
+
+		print(helpUsage.join(' '));
+
+		if (helpOptions) {
+			print.nn(helpOptions);
+		}
+
+		if (error) {
+			print();
+			print.bold((strings?.commands?.help?.error || 'Error: <message>')
+				.replace('<message>', error.message));
+		}
+
+		print();
+
+		process.exit(error ? 1 : 0);
+
+	};
+
+	const checkHelp = () => {
+		if (args[0] === '--help') printHelp();
+	};
+
 	return {
 		get base() {
 			return base;
 		},
 		command: async (commands) => {
 
-			const printHelp = (error) => {
+			helpUsage.push(`${opening}${strings?.commands?.help?.placeholder || 'command'}${closing}`);
+
+			helpOptions = print.toString((print) => {
 
-				print();
-				print((strings?.commands?.help?.usage || 'Usage: <base> <command>')
-					.replace('<base>', base)
-					.replace('<command>', `${opening}command${closing}`));
 				print();
 				print(strings?.commands?.help?.available || 'Available commands:');
 				print();
@@ -65,24 +110,15 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 
 				tools.sort((a, b) => a.name > b.name ? 1 : -1);
 
-				list(Object.fromEntries(tools
+				list(print, Object.fromEntries(tools
 					.map((tool) => [tool.name, tool.description || (strings?.commands?.help?.noDescription || 'No description')])));
 
-				if (error) {
-					print();
-					print();
-					print((strings?.commands?.help?.error || 'Error: <message>')
-						.replace('<message>', error.message));
-				}
-
-				print();
-
-				process.exit(error ? 1 : 0);
-
-			};
+			});
 
 			if (args.length === 0) printHelp();
 
+			checkHelp();
+
 			const tool = caseit(args[0]);
 
 			if (!commands[tool]) {
@@ -129,35 +165,46 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 				.all()
 				.filter((keyPath) => keyPath);
 
-			const printHelp = (error) => {
+			helpUsage.push(`${opening}${strings?.options?.help?.placeholder || 'options'}${closing}`);
 
-				if (typeof options?.command?.description === 'string') {
-					print();
-					print(options.command.description);
-				}
+			let shortOptions = {};
 
-				print();
-				print.nn(
-					(strings?.options?.help?.usage || 'Usage: <base> <options>')
-						.replace('<base>', base)
-						.replace('<options>', `${opening}options${closing}`));
+			allKeyPaths
+				.forEach((keyPath) => {
 
-				if (options.help?.postfix) print.nn(options.help.postfix);
+					const keyPathSchema = keyPaths(schema).get(keyPath);
 
-				print();
+					if (keyPathSchema.short) {
+
+						if (shortOptions[keyPathSchema.short]) {
+							throw new Error(`Short option "${keyPathSchema.short}" already used.`);
+						}
 
-				if (allKeyPaths.length) {
+						shortOptions[keyPath] = keyPathSchema.short;
+
+					}
+
+				});
+
+			if (allKeyPaths.length) {
+
+				helpOptions = print.toString((print) => {
 
 					print();
-					print(strings?.options?.help?.options || 'Options:');
+					print(strings?.options?.help?.title || 'Options:');
 
-					list(Object.fromEntries(allKeyPaths
+					list(print, Object.fromEntries(allKeyPaths
 						.map((keyPath) => {
 
 							const keyPathSchema = keyPaths(schema).get(keyPath);
 
+							let optionKeys = [`--${caseit(keyPath, 'kebab')}`];
 							let description = keyPathSchema.description || 'No description';
 
+							if (shortOptions[keyPath]) {
+								optionKeys.push(`-${shortOptions[keyPath]}`);
+							}
+
 							if (typeof keyPathSchema.enum !== 'undefined') {
 								description += ` (${Object.keys(keyPathSchema.enum).map((value) => `\`${value}\``).join(', ')})`;
 							}
@@ -172,10 +219,16 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 
 								let defaultDescription;
 
-								if (keyPathSchema.type === Boolean) {
-									defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
+								if (keyPathSchema.secret === true) {
+									defaultDescription = '`********`';
 								} else {
-									defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
+
+									if (keyPathSchema.type === Boolean) {
+										defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
+									} else {
+										defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
+									}
+
 								}
 
 								addition = ` ${(strings?.options?.help?.default || '(default: <default>)')
@@ -187,32 +240,20 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 
 							description += '.';
 
-							return [`--${caseit(keyPath, 'kebab')}`, description];
-
-						})));
-
-				}
-
-				print();
-
-				if (error) {
+							let option = optionKeys.reverse().join(', ');
 
-					(error.errors || [error])
-						.forEach((error) => {
-							if (error.keyPath) {
-								print.err(`--${caseit(error.keyPath.join('.'), 'kebab')}: ${error.message}`);
-							} else {
-								print.err(error.message);
+							if (keyPathSchema.type !== Boolean) {
+								option += ` ${strings?.options?.help?.argument || `${opening}${caseit(keyPath, 'kebab')}${closing}`}`;
 							}
-						});
 
-					print();
+							return [option, description];
 
-				}
+						})));
 
-				process.exit(error ? 1 : 0);
+				});
+			}
 
-			};
+			checkHelp();
 
 			let data = {};
 			let rest = [];
@@ -221,16 +262,22 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 
 			for (idx = 0 ; idx < args.length ; idx++) {
 
-				if (args[idx].slice(0, 2) !== '--') {
+				if (args[idx].slice(0, 1) !== '-') {
 					rest.push(args[idx]);
 					continue;
 				}
 
-				const arg = args[idx].slice(2);
+				shortOptions = Object.fromEntries(
+					Object.entries(shortOptions)
+						.map(([key, value]) => [value, key]));
 
-				const key = caseit(arg);
+				let key = args[idx].slice(1);
 
-				if (key === 'help') printHelp();
+				if (args[idx].slice(1, 2) === '-') {
+					key = caseit(args[idx].slice(2));
+				} else if (shortOptions[key]) {
+					key = caseit(shortOptions[key]);
+				}
 
 				if (!keyPaths(schema).all().includes(key)) {
 					printHelp(
@@ -268,7 +315,11 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 					aggregatedErrors: 'flatten'
 				});
 			} catch (error) {
-				printHelp(error);
+				let message = error.message;
+				if (error.keyPath?.[0]) {
+					message = `${caseit(error.keyPath[0], 'kebab')}: ${message}`;
+				}
+				printHelp(new Error(message));
 			}
 
 			return Object.assign({}, data, {
@@ -281,9 +332,47 @@ const argumentsParser = ({ args = process.argv.slice(2), argvLevel = 0, placehol
 			});
 
 		},
-		pop: async () => {
-			if (args.length === 0) return;
-			return args.shift();
+		values: async (schema) => {
+
+			schema = formalize(schema);
+
+			if (schema.type !== Object) {
+				throw new Error('Schema must be an object.');
+			}
+
+			const schemaKeyPaths = keyPaths(schema);
+
+			const allKeyPaths = schemaKeyPaths.all({ maxDepth: 2 })
+				.filter((keyPath) => keyPath);
+
+			let lastNonRequiredIndex = -1;
+
+			allKeyPaths
+				.forEach((keyPath, idx) => {
+
+					const schema = schemaKeyPaths.get(keyPath);
+
+					if (schema.required && idx > lastNonRequiredIndex + 1) {
+						throw new Error('Required arguments must come first.');
+					}
+
+					if (schema.type !== String) {
+						throw new Error('Schema must be an object of strings.');
+					}
+
+					helpUsage = helpUsage.concat([`${opening}${caseit(keyPath, 'kebab')}${closing}`]);
+
+				});
+
+			checkHelp();
+
+			try {
+				return await isvalid(Object.fromEntries(
+					allKeyPaths.map((keyPath, idx) => [keyPath, args[idx]])), schema);
+			} catch (error) {
+				return printHelp(error);
+			}
+
 		}
 	};
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@trenskow/arguments-parser",
-	"version": "0.2.12",
+	"version": "0.2.14",
 	"description": "Yet another arguments parser.",
 	"main": "index.js",
 	"type": "module",