@trenskow/arguments-parser 0.3.86 → 0.3.88

package/lib/index.js

@@ -9,7 +9,7 @@
 import { basename } from 'path';
 
 import caseit from '@trenskow/caseit';
-import { default as isvalid, keyPaths, formalize, plugins } from 'isvalid';
+import { default as isvalid, merge, keyPaths, plugins } from 'isvalid';
 import print from '@trenskow/print';
 
 plugins.use('argumentsParser.default', () => ({
@@ -54,7 +54,13 @@ const argumentsParser = (
 		help: {
 			usage: helpUsage,
 			options: helpOptions,
-		} = {}
+		} = {},
+		options = {
+			schema: {},
+			data: {},
+			validationOptions: {}
+		},
+		parameters = {}
 	} = {}
 ) => {
 
@@ -143,6 +149,32 @@ const argumentsParser = (
 		if (args[0] === '--help') printHelp();
 	};
 
+	const next = async (identifier, command) => {
+
+		try {
+
+			onCommand?.(identifier, args.slice(1));
+
+			return await command({
+				args: args.slice(1),
+				argumentsParser: argumentsParser({
+					args: args.slice(1),
+					argvLevel: argvLevel + 1,
+					onCommand,
+					placeholder,
+					command: command,
+					strings,
+					options,
+					parameters
+				})
+			});
+
+		} catch (error) {
+			print.err(`${error.stack}`);
+			process.exit(1);
+		}
+	};
+
 	const result = {
 		get base() {
 			return base;
@@ -182,292 +214,276 @@ const argumentsParser = (
 							.replace('<command>', args[0])));
 			}
 
-			try {
-
-				onCommand?.(tool, args.slice(1));
-
-				return await commands[tool]({
-					args: args.slice(1),
-					argumentsParser: argumentsParser({
-						args: args.slice(1),
-						argvLevel: argvLevel + 1,
-						onCommand,
-						placeholder,
-						command: commands[tool],
-						strings
-					})
-				});
+			return await next(
+				tool,
+				commands[tool]);
 
-			} catch (error) {
-				print.err(`${error.stack}`);
-				process.exit(1);
+		},
+		parameter: async (
+			identifier,
+			description,
+			schema,
+			command
+		) => {
+
+			if (typeof identifier !== 'string') {
+				throw new Error('Identifier must be a string');
 			}
 
-		},
-		options: async (schema, options = { }) => {
+			helpUsage.push(`${opening}${caseit(identifier, 'kebab')}${closing}`);
+
+			helpOptions = () => {
 
-			options.command = options.command || command;
+				print();
+				print(strings?.commands?.help?.available || 'Available commands:');
+				print();
 
-			schema = formalize(schema);
+				list(print, {
+					[`${opening}${caseit(identifier, 'kebab')}${closing}`]: description
+				});
 
-			let nonOptions;
-			let nonOptionsIndex = args.indexOf('--');
+			};
 
-			if (nonOptionsIndex > -1) {
-				nonOptions = args.slice(nonOptionsIndex + 1).join(' ');
-				args = args.slice(0, nonOptionsIndex);
-			}
+			if (args.length === 0) printHelp();
 
-			const allKeyPaths = keyPaths(schema)
-				.all()
-				.filter((keyPath) => keyPath);
+			checkHelp();
 
-			if (allKeyPaths.length) {
-				helpUsage.push(`${opening}${strings?.options?.help?.placeholder || 'options'}${closing}`);
-			}
+			parameters[identifier] = await isvalid(
+				args[0],
+				schema);
 
-			if (typeof options.usage === 'string') {
-				helpUsage.push(options.usage);
-			}
+			return await next(
+				identifier,
+				command);
 
-			let shortOptions = {};
+		},
+		options: (schema, validationOptions = { }) => {
 
-			allKeyPaths
-				.forEach((keyPath) => {
+			validationOptions.command = validationOptions.command || command;
 
-					const keyPathSchema = keyPaths(schema).get(keyPath);
+			Object.assign(
+				options.validationOptions,
+				validationOptions);
 
-					if (keyPathSchema.short) {
+			options.schema = merge(
+				options.schema)
+				.with(schema);
 
-						if (shortOptions[keyPathSchema.short]) {
-							throw new Error(`Short option "${keyPathSchema.short}" already used.`);
-						}
+			return result;
 
-						shortOptions[keyPath] = keyPathSchema.short;
+		},
+		help(error) {
+			printHelp(error);
+		},
+		then: (...resultArguments) => {
+			return (async () => {
 
-					}
+				checkHelp();
 
-				});
+				let nonOptions;
+				let nonOptionsIndex = args.indexOf('--');
 
-			shortOptions = Object.fromEntries(
-				Object.entries(shortOptions)
-					.map(([key, value]) => [value, key]));
+				if (nonOptionsIndex > -1) {
+					nonOptions = args.slice(nonOptionsIndex + 1).join(' ');
+					args = args.slice(0, nonOptionsIndex);
+				}
 
-			if (allKeyPaths.length) {
+				const allKeyPaths = keyPaths(options.schema)
+					.all()
+					.filter((keyPath) => keyPath);
 
-				helpOptions = () => {
+				if (allKeyPaths.length) {
+					helpUsage.push(`${opening}${strings?.options?.help?.placeholder || 'options'}${closing}`);
+				}
 
-					print();
-					print(strings?.options?.help?.title || 'Options:');
-					print();
+				if (typeof options.validationOptions.usage === 'string') {
+					helpUsage.push(options.validationOptions.usage);
+				}
 
-					list(print, Object.fromEntries(allKeyPaths
-						.map((keyPath) => {
+				let shortOptions = {};
 
-							const keyPathSchema = keyPaths(schema).get(keyPath);
+				allKeyPaths
+					.forEach((keyPath) => {
 
-							let optionKeys = [`--${caseit(keyPath, 'kebab')}`];
-							let description = [keyPathSchema.description || 'No description'];
+						const keyPathSchema = keyPaths(options.schema).get(keyPath);
 
-							if (shortOptions[keyPath]) {
-								optionKeys.push(`-${shortOptions[keyPath]}`);
-							}
+						if (keyPathSchema.short) {
 
-							if (typeof keyPathSchema.enum !== 'undefined') {
-								description.push(`(${opening}${keyPath}${closing}: ${Object.keys(keyPathSchema.enum).map((value) => `\`${value}\``).join(', ')})`);
+							if (shortOptions[keyPathSchema.short]) {
+								throw new Error(`Short option "${keyPathSchema.short}" already used.`);
 							}
 
-							if (keyPathSchema.type === Array) {
-								description.push(`${strings?.options?.help?.allowsMultiple || '(allows multiple)'}`);
-							} else if (keyPathSchema.required === true) {
-								description.push(`${strings?.options?.help?.required || '(required)'}`);
-							} else if (typeof keyPathSchema.default !== 'undefined') {
-
-								let defaultDescription;
+							shortOptions[keyPath] = keyPathSchema.short;
 
-								if (keyPathSchema.secret === true) {
-									defaultDescription = '`********`';
-								} else {
+						}
 
-									if (keyPathSchema.type === Boolean) {
-										defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
-									} else {
-										defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
-									}
+					});
 
-								}
+				shortOptions = Object.fromEntries(
+					Object.entries(shortOptions)
+						.map(([key, value]) => [value, key]));
 
-								description.push(`${(strings?.options?.help?.default || '(default: <default>)')
-									.replace('<default>', defaultDescription)}`);
+				if (allKeyPaths.length) {
 
-							}
+					helpOptions = () => {
 
-							if (keyPathSchema.hints?.length) {
-								description = description.concat(keyPathSchema.hints);
-							}
+						print();
+						print(strings?.options?.help?.title || 'Options:');
+						print();
 
-							let option = optionKeys.reverse().join(', ');
+						list(print, Object.fromEntries(allKeyPaths
+							.map((keyPath) => {
 
-							if (keyPathSchema.type !== Boolean) {
-								option += ` ${strings?.options?.help?.argument || `${opening}${caseit(keyPath, 'kebab')}${closing}`}`;
-							}
+								const keyPathSchema = keyPaths(options.schema).get(keyPath);
 
-							return [option, description];
+								let optionKeys = [`--${caseit(keyPath, 'kebab')}`];
+								let description = [keyPathSchema.description || 'No description'];
 
-						})), true);
+								if (shortOptions[keyPath]) {
+									optionKeys.push(`-${shortOptions[keyPath]}`);
+								}
 
-				};
-			}
+								if (typeof keyPathSchema.enum !== 'undefined') {
+									description.push(`(${opening}${keyPath}${closing}: ${Object.keys(keyPathSchema.enum).map((value) => `\`${value}\``).join(', ')})`);
+								}
 
-			checkHelp();
+								if (keyPathSchema.type === Array) {
+									description.push(`${strings?.options?.help?.allowsMultiple || '(allows multiple)'}`);
+								} else if (keyPathSchema.required === true) {
+									description.push(`${strings?.options?.help?.required || '(required)'}`);
+								} else if (typeof keyPathSchema.default !== 'undefined') {
 
-			let data = {};
-			let rest = [];
+									let defaultDescription;
 
-			let idx;
+									if (keyPathSchema.secret === true) {
+										defaultDescription = '`********`';
+									} else {
 
-			for (idx = 0 ; idx < args.length ; idx++) {
+										if (keyPathSchema.type === Boolean) {
+											defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
+										} else {
+											defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
+										}
 
-				if (args[idx].slice(0, 1) !== '-') {
-					rest.push(args[idx]);
-					continue;
-				}
+									}
 
-				let key = args[idx].slice(1);
+									description.push(`${(strings?.options?.help?.default || '(default: <default>)')
+										.replace('<default>', defaultDescription)}`);
 
-				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(
-						new Error(
-							(strings?.options?.help?.errors?.unknownOption || 'Unknown option: <option>.')
-								.replace('<option>', args[idx])));
-				}
+								if (keyPathSchema.hints?.length) {
+									description = description.concat(keyPathSchema.hints);
+								}
 
-				let value;
+								let option = optionKeys.reverse().join(', ');
 
-				if (keyPaths(schema).get(key).type === Boolean) {
-					value = true;
-				} else {
-					if (args.length <= idx + 1 || args[idx + 1].slice(0, 2) === '--') {
-						printHelp(
-							new Error(
-								(strings?.options?.help?.errors?.missingArgument || 'Argument missing for option: <option>.')
-									.replace('<option>', args[idx])));
-					}
-					value = args[++idx];
-				}
+								if (keyPathSchema.type !== Boolean) {
+									option += ` ${strings?.options?.help?.argument || `${opening}${caseit(keyPath, 'kebab')}${closing}`}`;
+								}
 
-				if (typeof data[key] === 'undefined') {
-					data[key] = value;
-				} else if (Array.isArray(data[key])) {
-					data[key].push(value);
-				} else {
-					data[key] = [data[key], value];
-				}
+								return [option, description];
 
-			}
+							})), true);
 
-			if (rest.length) {
-				switch (options.variadic || 'deny') {
-					case 'allow':
-						break;
-					case 'ignore':
-						rest = [];
-						break;
-					default:
-						printHelp(
-							new Error(
-								(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
-									.replace('<argument>', args[0])));
+					};
 				}
-			}
-
-			try {
-				data = await isvalid(data, schema, {
-					aggregatedErrors: 'flatten'
-				});
-			} catch (error) {
-				printHelp(error);
-			}
-
-			return Object.assign({}, data, {
-				onError: (error) => {
-					print.err(error.message);
-					process.exit(1);
-				},
-				rest,
-				nonOptions
-			});
-
-		},
-		empty: async () => {
 
-			checkHelp();
-
-			if (args.length > 0) {
-				printHelp(
-					new Error(
-						(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
-							.replace('<argument>', args[0])));
-			}
+				let rest = [];
 
-		},
-		values: async (schema) => {
+				let idx;
 
-			schema = formalize(schema);
+				for (idx = 0 ; idx < args.length ; idx++) {
 
-			if (schema.type !== Object) {
-				throw new Error('Schema must be an object.');
-			}
+					if (args[idx].slice(0, 1) !== '-') {
+						rest.push(args[idx]);
+						continue;
+					}
 
-			const schemaKeyPaths = keyPaths(schema);
+					let key = args[idx].slice(1);
 
-			const allKeyPaths = schemaKeyPaths.all({ maxDepth: 2 })
-				.filter((keyPath) => keyPath);
+					if (args[idx].slice(1, 2) === '-') {
+						key = caseit(args[idx].slice(2));
+					} else if (shortOptions[key]) {
+						key = caseit(shortOptions[key]);
+					}
 
-			let lastNonRequiredIndex = -1;
+					if (!keyPaths(options.schema).all().includes(key)) {
+						printHelp(
+							new Error(
+								(strings?.options?.help?.errors?.unknownOption || 'Unknown option: <option>.')
+									.replace('<option>', args[idx])));
+					}
 
-			allKeyPaths
-				.forEach((keyPath, idx) => {
+					let value;
 
-					const schema = schemaKeyPaths.get(keyPath);
+					if (keyPaths(options.schema).get(key).type === Boolean) {
+						value = true;
+					} else {
+						if (args.length <= idx + 1 || args[idx + 1].slice(0, 2) === '--') {
+							printHelp(
+								new Error(
+									(strings?.options?.help?.errors?.missingArgument || 'Argument missing for option: <option>.')
+										.replace('<option>', args[idx])));
+						}
+						value = args[++idx];
+					}
 
-					if (schema.required && idx > lastNonRequiredIndex + 1) {
-						throw new Error('Required arguments must come first.');
+					if (typeof options.data[key] === 'undefined') {
+						options.data[key] = value;
+					} else if (Array.isArray(options.data[key])) {
+						options.data[key].push(value);
+					} else {
+						options.data[key] = [options.data[key], value];
 					}
 
-					if (schema.type !== String) {
-						throw new Error('Schema must be an object of strings.');
+				}
+
+				if (rest.length) {
+					switch (options.validationOptions.variadic || 'deny') {
+						case 'allow':
+							break;
+						case 'ignore':
+							rest = [];
+							break;
+						default:
+							printHelp(
+								new Error(
+									(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
+										.replace('<argument>', args[0])));
 					}
+				}
 
-					helpUsage = helpUsage.concat([`${opening}${caseit(keyPath, 'kebab')}${closing}`]);
+				if (args.length > 0) {
+					printHelp(
+						new Error(
+							(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
+								.replace('<argument>', args[0])));
+				}
 
-				});
+				let data = {};
 
-			checkHelp();
+				try {
+					data = await isvalid(options.data, options.schema, {
+						aggregatedErrors: 'flatten'
+					});
+				} catch (error) {
+					printHelp(error);
+				}
 
-			try {
-				return await isvalid(Object.fromEntries(
-					allKeyPaths.map((keyPath, idx) => [keyPath, args[idx]])), schema);
-			} catch (error) {
-				return printHelp(error);
-			}
+				return Object.assign({}, parameters, data, {
+					onError: (error) => {
+						print.err(error.message);
+						process.exit(1);
+					},
+					rest,
+					nonOptions
+				});
 
-		},
-		help(error) {
-			printHelp(error);
+			})().then(...resultArguments);
 		}
 	};
 
-	result.then = (...args) => {
-		return result.empty().then(...args);
-	};
-
 	return result;
 
 };

package/package.json

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