@trenskow/arguments-parser 0.3.136 → 0.3.138

package/index.js

@@ -6,87 +6,4 @@
 // See license in LICENSE.
 //
 
-import {
-	basename,
-	extname
-} from 'path';
-
-import {
-	plugins
-} from 'isvalid';
-
-import argumentsParser from './lib/index.js';
-import autocomplete from './lib/autocomplete/index.js';
-
-plugins.use('argumentsParser.dummies', () => ({
-	phase: 'pre',
-	supportsType: () => true,
-	validatorsForType: () => ({
-		description: ['string'],
-		defaultDescription: ['string'],
-		secret: ['boolean'],
-		short: ['string']
-	}),
-	validate: (data) => data,
-	formalize: (schema) => schema
-}));
-
-plugins.use('argumentsParser.hints', () => ({
-	phase: 'pre',
-	supportsType: () => true,
-	validatorsForType: () => ({
-		hints: ['array', 'string']
-	}),
-	validate: (data) => data,
-	formalize: (data, _, schema) => {
-
-		if (!Array.isArray(data)) data = [data];
-
-		if (schema.errors.hints) {
-			data.push(schema.errors.hints);
-			delete schema.errors.hints;
-		}
-
-		if (data.some((data) => typeof data !== 'string')) throw new Error('Must be a string.');
-
-		return data;
-
-	}
-}));
-
-plugins.use('argumentsParser.autocomplete', () => ({
-	phase: 'pre',
-	supportsType: () => true,
-	validatorsForType: () => ({
-		autocomplete: ['array', 'function']
-	}),
-	validate: (data) => data,
-	formalize: (data) => {
-
-		if (!(Array.isArray(data) && data.every((data) => typeof data === 'string')) && typeof data !== 'function') {
-			throw new Error('Must be a string or a function.');
-		}
-
-		return data;
-
-	}
-}));
-
-if (process.argv[2] === '_completion') {
-
-	let command = basename(process.env.COMPLETION_PATH || process.argv[1]);
-
-	const ext = extname(command);
-
-	if (ext.length) command = command.slice(0, -ext.length);
-
-	autocomplete.script({
-		shell: process.argv[3],
-		command
-	});
-
-	process.exit(0);
-
-}
-
-export default typeof process.env.AUTOCOMPLETE_INDEX !== 'undefined' ? autocomplete() : argumentsParser;
+export { default } from './lib/index.js';

package/lib/arguments-parser.js

@@ -0,0 +1,488 @@
+//
+// arguments-parser.js
+// @trenskow/arguments-parser
+//
+// Created by Kristian Trenskow on 2023/08/07
+// See license in LICENSE.
+//
+
+import {
+	basename
+} from 'path';
+
+import caseit from '@trenskow/caseit';
+import { default as isvalid, merge, keyPaths } from 'isvalid';
+import print from '@trenskow/print';
+
+const argumentsParser = (
+	{
+		args = process.argv.slice(2),
+		argvLevel = 0,
+		placeholder = '<>',
+		command,
+		onCommand,
+		onParameter,
+		strings = {},
+		help: {
+			usage: helpUsage,
+			options: helpOptions,
+		} = {},
+		options = {
+			schema: {},
+			data: {},
+			validationOptions: {}
+		},
+		parameters = {}
+	} = {}
+) => {
+
+	const [opening, closing] = placeholder.split('');
+
+	const base = `${process.argv.slice(1, argvLevel + 2).map(((arg) => basename(arg))).join(' ')}`;
+
+	const list = (print, items, spacing = false) => {
+
+		const maxLength = Object.keys(items)
+			.reduce((length, key) => Math.max(length, key.length), 0);
+
+		Object.entries(items)
+			.forEach(([key, description], idx) => {
+
+				if (spacing && idx > 0) print();
+
+				print.nn(`  ${key}`, { minimumLength: maxLength + 4 });
+
+				if (!Array.isArray(description)) description = [description];
+
+				description
+					.forEach((description, idx) => {
+
+						if (idx > 0) {
+							print.nn('', { minimumLength: maxLength + 4 });
+						}
+
+						print.sentence(description);
+
+					});
+
+			});
+
+	};
+
+	if (typeof helpUsage === 'undefined') {
+		helpUsage = [
+			strings?.help?.usage || 'Usage:',
+			base
+		];
+	}
+
+	const printHelp = (error) => {
+
+		print();
+
+		if (command) {
+			print.bold(command.description);
+			print();
+		}
+
+		print(helpUsage.join(' '));
+
+		if (helpOptions) {
+			print.nn(helpOptions());
+		}
+
+		if (error) {
+
+			print();
+
+			(error.errors || [error])
+				.forEach((error) => {
+
+					let message = error.message;
+
+					if (error.keyPath?.[0]) {
+						message = `${caseit(error.keyPath[0], 'kebab')}: ${message}`;
+					}
+
+					print.bold((strings?.commands?.help?.error || 'Error: <message>')
+						.replace('<message>', message));
+
+				});
+
+		}
+
+		print();
+
+		process.exit(error ? 1 : 0);
+
+	};
+
+	const checkHelp = () => {
+		if (args[0] === '--help') printHelp();
+	};
+
+	const next = async (identifier, command) => {
+
+		try {
+
+			return await command({
+				args: args.slice(1),
+				argumentsParser: argumentsParser({
+					args: args.slice(1),
+					argvLevel: argvLevel + 1,
+					onCommand,
+					onParameter,
+					placeholder,
+					command: command,
+					strings,
+					options,
+					parameters
+				}),
+				parameters
+			});
+
+		} catch (error) {
+			print.err(`${error.stack}`);
+			process.exit(1);
+		}
+
+	};
+
+	const result = {
+		get base() {
+			return base;
+		},
+		command: async (commands) => {
+
+			helpUsage.push(`${opening}${strings?.commands?.help?.placeholder || 'command'}${closing}`);
+
+			helpOptions = () => {
+
+				print();
+				print(strings?.commands?.help?.available || 'Available commands:');
+				print();
+
+				const tools = Object.entries(commands).map(([key, command]) => ({
+					name: `${caseit(key, 'kebab')}${Array.isArray(command.parameters) ? ` ${command.parameters.map((parameter) => `${opening}${caseit(parameter, 'kebab')}${closing}`).join(' ')}` : ''}`,
+					description: commands[key].description
+				}));
+
+				tools.sort((a, b) => a.name > b.name ? 1 : -1);
+
+				list(print, Object.fromEntries(tools
+					.map((tool) => [tool.name, tool.description || (strings?.commands?.help?.noDescription || 'No description')])));
+
+			};
+
+			if (args.length === 0) printHelp();
+
+			checkHelp();
+
+			const tool = caseit(args[0]);
+
+			if (!commands[tool]) {
+				printHelp(
+					new Error(
+						(strings?.commands?.help?.errors?.notFound || '<command>: Command not found')
+							.replace('<command>', args[0])));
+			}
+
+			onCommand?.(tool, args.slice(1));
+
+			return await next(
+				tool,
+				commands[tool]);
+
+		},
+		parameter: async ({
+			identifier,
+			description,
+			schema
+		} = {}, command) => {
+
+			if (typeof identifier !== 'string') {
+				throw new Error('Identifier must be a string');
+			}
+
+			description = description || command.description || strings?.commands?.help?.noDescription || 'No description.';
+
+			helpUsage.push(`${opening}${caseit(identifier, 'kebab')}${closing}`);
+
+			helpOptions = () => {
+
+				print();
+				print(strings?.commands?.help?.available || 'Available commands:');
+				print();
+
+				list(print, {
+					[`${opening}${caseit(identifier, 'kebab')}${closing}`]: description
+				});
+
+			};
+
+			if (args.length === 0) printHelp();
+
+			checkHelp();
+
+			parameters[identifier] = args[0];
+
+			try {
+				if (typeof schema !== 'undefined') {
+					parameters[identifier] = await isvalid(
+						parameters[identifier],
+						schema);
+				}
+			} catch (error) {
+				printHelp(error);
+			}
+
+			(onParameter || onCommand)?.(identifier, args.slice(1));
+
+			return await next(
+				identifier,
+				command);
+
+		},
+		options: (schema, validationOptions = {}) => {
+
+			validationOptions.command = validationOptions.command || command;
+
+			Object.assign(
+				options.validationOptions,
+				validationOptions);
+
+			options.schema = merge(
+				schema, {
+					transform: {
+						post: (key, validator) => {
+							if (key === 'enum') {
+								return validator.map((value) => caseit(value, 'kebab'));
+							}
+						}
+					}
+				})
+				.with(options.schema);
+
+			return result;
+
+		},
+		help(error) {
+			printHelp(error);
+		},
+		then: (...resultArguments) => {
+			return (async () => {
+
+				let nonOptions;
+				let nonOptionsIndex = args.indexOf('--');
+
+				if (nonOptionsIndex > -1) {
+					nonOptions = args.slice(nonOptionsIndex + 1).join(' ');
+					args = args.slice(0, nonOptionsIndex);
+				}
+
+				const allKeyPaths = keyPaths(options.schema)
+					.all()
+					.filter((keyPath) => keyPath);
+
+				if (allKeyPaths.length) {
+					helpUsage.push(`${opening}${strings?.options?.help?.placeholder || 'options'}${closing}`);
+				}
+
+				if (typeof options.validationOptions.usage === 'string') {
+					helpUsage.push(options.validationOptions.usage);
+				}
+
+				let shortOptions = {};
+
+				allKeyPaths
+					.forEach((keyPath) => {
+
+						const keyPathSchema = keyPaths(options.schema).get(keyPath);
+
+						if (keyPathSchema.short) {
+
+							if (shortOptions[keyPathSchema.short]) {
+								throw new Error(`Short option "${keyPathSchema.short}" already used.`);
+							}
+
+							shortOptions[keyPath] = keyPathSchema.short;
+
+						}
+
+					});
+
+				shortOptions = Object.fromEntries(
+					Object.entries(shortOptions)
+						.map(([key, value]) => [value, key]));
+
+				if (allKeyPaths.length) {
+
+					helpOptions = () => {
+
+						print();
+						print(strings?.options?.help?.title || 'Options:');
+						print();
+
+						list(print, Object.fromEntries(allKeyPaths
+							.map((keyPath) => {
+
+								const keyPathSchema = keyPaths(options.schema).get(keyPath);
+
+								let optionKeys = [`--${caseit(keyPath, 'kebab')}`];
+
+								let description = [keyPathSchema.description || strings?.commands?.help?.noDescription || 'No description'];
+
+								if (keyPathSchema.short) {
+									optionKeys.push(`-${keyPathSchema.short}`);
+								}
+
+								if (typeof keyPathSchema.enum !== 'undefined') {
+									description.push(`(${opening}${keyPath}${closing}: ${Object.keys(keyPathSchema.enum).map((value) => `\`${value}\``).join(', ')})`);
+								}
+
+								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;
+
+									if (keyPathSchema.secret === true) {
+										defaultDescription = '`********`';
+									} else {
+
+										if (keyPathSchema.type === Boolean) {
+											defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
+										} else {
+											defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
+										}
+
+									}
+
+									description.push(`${(strings?.options?.help?.default || '(default: <default>)')
+										.replace('<default>', defaultDescription)}`);
+
+								}
+
+								if (keyPathSchema.hints?.length) {
+									description = description.concat(keyPathSchema.hints);
+								}
+
+								let option = optionKeys.reverse().join(', ');
+
+								if (keyPathSchema.type !== Boolean) {
+									option += ` ${strings?.options?.help?.argument || `${opening}${caseit(keyPath, 'kebab')}${closing}`}`;
+								}
+
+								return [option, description];
+
+							})), true);
+
+					};
+				}
+
+				checkHelp();
+
+				let rest = [];
+
+				let idx;
+
+				checkHelp();
+
+				for (idx = 0; idx < args.length; idx++) {
+
+					if (args[idx].slice(0, 1) !== '-') {
+						rest.push(args[idx]);
+						continue;
+					}
+
+					let key = args[idx].slice(1);
+
+					if (args[idx].slice(1, 2) === '-') {
+						key = caseit(args[idx].slice(2));
+					} else if (shortOptions[key]) {
+						key = caseit(shortOptions[key]);
+					}
+
+					if (!keyPaths(options.schema).all().includes(key)) {
+						printHelp(
+							new Error(
+								(strings?.options?.help?.errors?.unknownOption || 'Unknown option: <option>.')
+									.replace('<option>', args[idx])));
+					}
+
+					let value;
+
+					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 (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 (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])));
+					}
+				}
+
+				if (args.length - idx > 0) {
+					printHelp(
+						new Error(
+							(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
+								.replace('<argument>', args[0])));
+				}
+
+				let data = {};
+
+				try {
+					data = await isvalid(options.data, options.schema, {
+						aggregatedErrors: 'flatten'
+					});
+				} catch (error) {
+					printHelp(error);
+				}
+
+				return Object.assign({}, data, {
+					onError: (error) => {
+						print.err(error.message);
+						process.exit(1);
+					},
+					rest,
+					nonOptions
+				});
+
+			})().then(...resultArguments);
+		}
+	};
+
+	return result;
+
+};
+
+export default argumentsParser;

package/lib/autocomplete/index.js

@@ -27,7 +27,7 @@ const supported = {
 
 const currentShell = basename(process.env.SHELL || '');
 
-const argumentsParser = () => {
+const autocomplete = () => {
 
 	const writer = supported[currentShell];
 
@@ -188,15 +188,7 @@ const argumentsParser = () => {
 					validationOptions);
 
 				options.schema = merge(
-					schema, {
-						transform: {
-							post: (key, validator) => {
-								if (key === 'enum') {
-									return validator.map((value) => caseit(value, 'kebab'));
-								}
-							}
-						}
-					})
+					schema)
 					.with(options.schema);
 
 				return result;
@@ -240,7 +232,7 @@ const argumentsParser = () => {
 
 							if (schemas[idx].enum) {
 								return Object.keys(schemas[idx].enum)
-									.filter((item) => caseit(key, 'kebab') !== item && item.startsWith(current))
+									.filter((item) => key !== item && item.startsWith(current))
 									.map((item) => ({
 										type: 'option',
 										argument: caseit(item, 'kebab')
@@ -351,7 +343,7 @@ const argumentsParser = () => {
 
 };
 
-argumentsParser.script = ({
+autocomplete.script = ({
 	shell = currentShell,
 	command
 }) => {
@@ -370,4 +362,4 @@ argumentsParser.script = ({
 
 };
 
-export default argumentsParser;
+export default autocomplete;

package/lib/index.js

@@ -2,487 +2,37 @@
 // index.js
 // @trenskow/arguments-parser
 //
-// Created by Kristian Trenskow on 2023/08/07
+// Created by Kristian Trenskow on 2026/08/04
 // See license in LICENSE.
 //
 
 import {
-	basename
+	basename,
+	extname
 } from 'path';
 
-import caseit from '@trenskow/caseit';
-import { default as isvalid, merge, keyPaths } from 'isvalid';
-import print from '@trenskow/print';
+import plugins from './plugins/index.js';
 
-const argumentsParser = (
-	{
-		args = process.argv.slice(2),
-		argvLevel = 0,
-		placeholder = '<>',
-		command,
-		onCommand,
-		onParameter,
-		strings = {},
-		help: {
-			usage: helpUsage,
-			options: helpOptions,
-		} = {},
-		options = {
-			schema: {},
-			data: {},
-			validationOptions: {}
-		},
-		parameters = {}
-	} = {}
-) => {
+import argumentsParser from './arguments-parser.js';
+import autocomplete from './autocomplete/index.js';
 
-	const [opening, closing] = placeholder.split('');
+plugins();
 
-	const base = `${process.argv.slice(1, argvLevel + 2).map(((arg) => basename(arg))).join(' ')}`;
+if (process.argv[2] === '_completion') {
 
-	const list = (print, items, spacing = false) => {
+	let command = basename(process.env.COMPLETION_PATH || process.argv[1]);
 
-		const maxLength = Object.keys(items)
-			.reduce((length, key) => Math.max(length, key.length), 0);
+	const ext = extname(command);
 
-		Object.entries(items)
-			.forEach(([key, description], idx) => {
+	if (ext.length) command = command.slice(0, -ext.length);
 
-				if (spacing && idx > 0) print();
+	autocomplete.script({
+		shell: process.argv[3],
+		command
+	});
 
-				print.nn(`  ${key}`, { minimumLength: maxLength + 4 });
+	process.exit(0);
 
-				if (!Array.isArray(description)) description = [description];
+}
 
-				description
-					.forEach((description, idx) => {
-
-						if (idx > 0) {
-							print.nn('', { minimumLength: maxLength + 4 });
-						}
-
-						print.sentence(description);
-
-					});
-
-			});
-
-	};
-
-	if (typeof helpUsage === 'undefined') {
-		helpUsage = [
-			strings?.help?.usage || 'Usage:',
-			base
-		];
-	}
-
-	const printHelp = (error) => {
-
-		print();
-
-		if (command) {
-			print.bold(command.description);
-			print();
-		}
-
-		print(helpUsage.join(' '));
-
-		if (helpOptions) {
-			print.nn(helpOptions());
-		}
-
-		if (error) {
-
-			print();
-
-			(error.errors || [error])
-				.forEach((error) => {
-
-					let message = error.message;
-
-					if (error.keyPath?.[0]) {
-						message = `${caseit(error.keyPath[0], 'kebab')}: ${message}`;
-					}
-
-					print.bold((strings?.commands?.help?.error || 'Error: <message>')
-						.replace('<message>', message));
-
-				});
-
-		}
-
-		print();
-
-		process.exit(error ? 1 : 0);
-
-	};
-
-	const checkHelp = () => {
-		if (args[0] === '--help') printHelp();
-	};
-
-	const next = async (identifier, command) => {
-
-		try {
-
-			return await command({
-				args: args.slice(1),
-				argumentsParser: argumentsParser({
-					args: args.slice(1),
-					argvLevel: argvLevel + 1,
-					onCommand,
-					onParameter,
-					placeholder,
-					command: command,
-					strings,
-					options,
-					parameters
-				}),
-				parameters
-			});
-
-		} catch (error) {
-			print.err(`${error.stack}`);
-			process.exit(1);
-		}
-
-	};
-
-	const result = {
-		get base() {
-			return base;
-		},
-		command: async (commands) => {
-
-			helpUsage.push(`${opening}${strings?.commands?.help?.placeholder || 'command'}${closing}`);
-
-			helpOptions = () => {
-
-				print();
-				print(strings?.commands?.help?.available || 'Available commands:');
-				print();
-
-				const tools = Object.entries(commands).map(([key, command]) => ({
-					name: `${caseit(key, 'kebab')}${Array.isArray(command.parameters) ? ` ${command.parameters.map((parameter) => `${opening}${caseit(parameter, 'kebab')}${closing}`).join(' ')}` : ''}`,
-					description: commands[key].description
-				}));
-
-				tools.sort((a, b) => a.name > b.name ? 1 : -1);
-
-				list(print, Object.fromEntries(tools
-					.map((tool) => [tool.name, tool.description || (strings?.commands?.help?.noDescription || 'No description')])));
-
-			};
-
-			if (args.length === 0) printHelp();
-
-			checkHelp();
-
-			const tool = caseit(args[0]);
-
-			if (!commands[tool]) {
-				printHelp(
-					new Error(
-						(strings?.commands?.help?.errors?.notFound || '<command>: Command not found')
-							.replace('<command>', args[0])));
-			}
-
-			onCommand?.(tool, args.slice(1));
-
-			return await next(
-				tool,
-				commands[tool]);
-
-		},
-		parameter: async ({
-			identifier,
-			description,
-			schema
-		} = {}, command) => {
-
-			if (typeof identifier !== 'string') {
-				throw new Error('Identifier must be a string');
-			}
-
-			description = description || command.description || strings?.commands?.help?.noDescription || 'No description.';
-
-			helpUsage.push(`${opening}${caseit(identifier, 'kebab')}${closing}`);
-
-			helpOptions = () => {
-
-				print();
-				print(strings?.commands?.help?.available || 'Available commands:');
-				print();
-
-				list(print, {
-					[`${opening}${caseit(identifier, 'kebab')}${closing}`]: description
-				});
-
-			};
-
-			if (args.length === 0) printHelp();
-
-			checkHelp();
-
-			parameters[identifier] = args[0];
-
-			try {
-				if (typeof schema !== 'undefined') {
-					parameters[identifier] = await isvalid(
-						parameters[identifier],
-						schema);
-				}
-			} catch (error) {
-				printHelp(error);
-			}
-
-			(onParameter || onCommand)?.(identifier, args.slice(1));
-
-			return await next(
-				identifier,
-				command);
-
-		},
-		options: (schema, validationOptions = {}) => {
-
-			validationOptions.command = validationOptions.command || command;
-
-			Object.assign(
-				options.validationOptions,
-				validationOptions);
-
-			options.schema = merge(
-				schema, {
-					transform: {
-						post: (key, validator) => {
-							if (key === 'enum') {
-								return validator.map((value) => caseit(value, 'kebab'));
-							}
-						}
-					}
-				})
-				.with(options.schema);
-
-			return result;
-
-		},
-		help(error) {
-			printHelp(error);
-		},
-		then: (...resultArguments) => {
-			return (async () => {
-
-				let nonOptions;
-				let nonOptionsIndex = args.indexOf('--');
-
-				if (nonOptionsIndex > -1) {
-					nonOptions = args.slice(nonOptionsIndex + 1).join(' ');
-					args = args.slice(0, nonOptionsIndex);
-				}
-
-				const allKeyPaths = keyPaths(options.schema)
-					.all()
-					.filter((keyPath) => keyPath);
-
-				if (allKeyPaths.length) {
-					helpUsage.push(`${opening}${strings?.options?.help?.placeholder || 'options'}${closing}`);
-				}
-
-				if (typeof options.validationOptions.usage === 'string') {
-					helpUsage.push(options.validationOptions.usage);
-				}
-
-				let shortOptions = {};
-
-				allKeyPaths
-					.forEach((keyPath) => {
-
-						const keyPathSchema = keyPaths(options.schema).get(keyPath);
-
-						if (keyPathSchema.short) {
-
-							if (shortOptions[keyPathSchema.short]) {
-								throw new Error(`Short option "${keyPathSchema.short}" already used.`);
-							}
-
-							shortOptions[keyPath] = keyPathSchema.short;
-
-						}
-
-					});
-
-				shortOptions = Object.fromEntries(
-					Object.entries(shortOptions)
-						.map(([key, value]) => [value, key]));
-
-				if (allKeyPaths.length) {
-
-					helpOptions = () => {
-
-						print();
-						print(strings?.options?.help?.title || 'Options:');
-						print();
-
-						list(print, Object.fromEntries(allKeyPaths
-							.map((keyPath) => {
-
-								const keyPathSchema = keyPaths(options.schema).get(keyPath);
-
-								let optionKeys = [`--${caseit(keyPath, 'kebab')}`];
-
-								let description = [keyPathSchema.description || strings?.commands?.help?.noDescription || 'No description'];
-
-								if (keyPathSchema.short) {
-									optionKeys.push(`-${keyPathSchema.short}`);
-								}
-
-								if (typeof keyPathSchema.enum !== 'undefined') {
-									description.push(`(${opening}${keyPath}${closing}: ${Object.keys(keyPathSchema.enum).map((value) => `\`${caseit(value, 'kebab')}\``).join(', ')})`);
-								}
-
-								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;
-
-									if (keyPathSchema.secret === true) {
-										defaultDescription = '`********`';
-									} else {
-
-										if (keyPathSchema.type === Boolean) {
-											defaultDescription = keyPathSchema.default === true ? 'enabled' : 'disabled';
-										} else {
-											defaultDescription = `\`${keyPathSchema.defaultDescription ?? keyPathSchema.default}\``;
-										}
-
-									}
-
-									description.push(`${(strings?.options?.help?.default || '(default: <default>)')
-										.replace('<default>', defaultDescription)}`);
-
-								}
-
-								if (keyPathSchema.hints?.length) {
-									description = description.concat(keyPathSchema.hints);
-								}
-
-								let option = optionKeys.reverse().join(', ');
-
-								if (keyPathSchema.type !== Boolean) {
-									option += ` ${strings?.options?.help?.argument || `${opening}${caseit(keyPath, 'kebab')}${closing}`}`;
-								}
-
-								return [option, description];
-
-							})), true);
-
-					};
-				}
-
-				checkHelp();
-
-				let rest = [];
-
-				let idx;
-
-				checkHelp();
-
-				for (idx = 0; idx < args.length; idx++) {
-
-					if (args[idx].slice(0, 1) !== '-') {
-						rest.push(args[idx]);
-						continue;
-					}
-
-					let key = args[idx].slice(1);
-
-					if (args[idx].slice(1, 2) === '-') {
-						key = caseit(args[idx].slice(2));
-					} else if (shortOptions[key]) {
-						key = caseit(shortOptions[key]);
-					}
-
-					if (!keyPaths(options.schema).all().includes(key)) {
-						printHelp(
-							new Error(
-								(strings?.options?.help?.errors?.unknownOption || 'Unknown option: <option>.')
-									.replace('<option>', args[idx])));
-					}
-
-					let value;
-
-					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 (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 (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])));
-					}
-				}
-
-				if (args.length - idx > 0) {
-					printHelp(
-						new Error(
-							(strings?.empty?.help?.errors?.unexpected || 'Unexpected argument: <argument>.')
-								.replace('<argument>', args[0])));
-				}
-
-				let data = {};
-
-				try {
-					data = await isvalid(options.data, options.schema, {
-						aggregatedErrors: 'flatten'
-					});
-				} catch (error) {
-					printHelp(error);
-				}
-
-				return Object.assign({}, data, {
-					onError: (error) => {
-						print.err(error.message);
-						process.exit(1);
-					},
-					rest,
-					nonOptions
-				});
-
-			})().then(...resultArguments);
-		}
-	};
-
-	return result;
-
-};
-
-export default argumentsParser;
+export default typeof process.env.AUTOCOMPLETE_INDEX !== 'undefined' ? autocomplete() : argumentsParser;

package/lib/plugins/autocomplete.js

@@ -0,0 +1,25 @@
+//
+// autocomplete.js
+// @trenskow/arguments-parser
+//
+// Created by Kristian Trenskow on 2028/08/04
+// See license in LICENSE.
+//
+
+export default () => ({
+	phase: 'pre',
+	supportsType: () => true,
+	validatorsForType: () => ({
+		autocomplete: ['array', 'function']
+	}),
+	validate: (data) => data,
+	formalize: (data) => {
+
+		if (!(Array.isArray(data) && data.every((data) => typeof data === 'string')) && typeof data !== 'function') {
+			throw new Error('Must be a string or a function.');
+		}
+
+		return data;
+
+	}
+});

package/lib/plugins/dummies.js

@@ -0,0 +1,20 @@
+//
+// dummies.js
+// @trenskow/arguments-parser
+//
+// Created by Kristian Trenskow on 2028/08/04
+// See license in LICENSE.
+//
+
+export default () => ({
+	phase: 'pre',
+	supportsType: () => true,
+	validatorsForType: () => ({
+		description: ['string'],
+		defaultDescription: ['string'],
+		secret: ['boolean'],
+		short: ['string']
+	}),
+	validate: (data) => data,
+	formalize: (schema) => schema
+});

package/lib/plugins/hints.js

@@ -0,0 +1,30 @@
+//
+// hints.js
+// @trenskow/arguments-parser
+//
+// Created by Kristian Trenskow on 2028/08/04
+// See license in LICENSE.
+//
+
+export default () => ({
+	phase: 'pre',
+	supportsType: () => true,
+	validatorsForType: () => ({
+		hints: ['array', 'string']
+	}),
+	validate: (data) => data,
+	formalize: (data, _, schema) => {
+
+		if (!Array.isArray(data)) data = [data];
+
+		if (schema.errors.hints) {
+			data.push(schema.errors.hints);
+			delete schema.errors.hints;
+		}
+
+		if (data.some((data) => typeof data !== 'string')) throw new Error('Must be a string.');
+
+		return data;
+
+	}
+});

package/lib/plugins/index.js

@@ -0,0 +1,21 @@
+//
+// plugins.js
+// @trenskow/arguments-parser
+//
+// Created by Kristian Trenskow on 2028/08/04
+// See license in LICENSE.
+//
+
+import {
+	plugins
+} from 'isvalid';
+
+import autocomplete from './autocomplete.js';
+import dummies from './dummies.js';
+import hints from './hints.js';
+
+export default () => {
+	plugins.use('argumentsParser.dummies', dummies);
+	plugins.use('argumentsParser.hints', hints);
+	plugins.use('argumentsParser.autocomplete', autocomplete);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@trenskow/arguments-parser",
-	"version": "0.3.136",
+	"version": "0.3.138",
 	"description": "Yet another arguments parser.",
 	"main": "index.js",
 	"type": "module",
@@ -26,7 +26,7 @@
 	"dependencies": {
 		"@trenskow/caseit": "^1.4.30",
 		"@trenskow/parallel": "^0.1.136",
-		"@trenskow/print": "^0.1.74",
+		"@trenskow/print": "^0.1.75",
 		"isvalid": "^5.0.21"
 	},
 	"devDependencies": {