@trenskow/arguments-parser 0.3.140 → 0.3.142

package/lib/autocomplete/bash.js

@@ -59,8 +59,6 @@ const bash = (items) => {
 		process.stdout.write('COMPREPLY+=($(compgen -f -- "${COMP_WORDS[COMP_CWORD]}"))\n');
 	}
 
-	process.exit(0);
-
 };
 
 bash.script = ({

package/lib/autocomplete/index.js

@@ -105,24 +105,30 @@ const autocomplete = () => {
 				}
 			});
 
-		const output = (items) => writer(
-			filter(items)
-				.reduce((grouped, item) => {
-
-					grouped[item.type] = grouped[item.type] || [];
-
-					switch (item.type) {
-						case 'option':
-							// fall through
-						case 'command':
-							grouped[item.type].push(item);
-							break;
-						default:
-					}
+		const output = (items) => {
+
+			writer(
+				filter(items)
+					.reduce((grouped, item) => {
+
+						grouped[item.type] = grouped[item.type] || [];
+
+						switch (item.type) {
+							case 'option':
+								// fall through
+							case 'command':
+								grouped[item.type].push(item);
+								break;
+							default:
+						}
 
-					return grouped;
+						return grouped;
 
-				}, {}));
+					}, {}));
+
+			process.exit(0);
+
+		};
 
 		const result = {
 			get base() {
@@ -196,15 +202,17 @@ const autocomplete = () => {
 				return (async () => {
 
 					const {
-						variadic,
-						autocomplete = () => [{
-							type: 'files'
-						}]
+						variadic
 					} = options.validationOptions;
 
-					const nonOptions = args
+					if (args
 						.slice(0, autocompleteIndex)
-						.some((arg) => arg === '--');
+						.some((arg) => arg === '--')
+					) {
+						output([{
+							type: 'files'
+						}]);
+					}
 
 					const allKeyPaths = keyPaths(options.schema)
 						.all()
@@ -214,107 +222,101 @@ const autocomplete = () => {
 					let schemas = {};
 					let spent = [];
 
-					const complete = async (current = args[autocompleteIndex] || '') => {
+					for (idx = 0; idx < autocompleteIndex || idx < args.length; idx++) {
 
-						if (nonOptions) {
-							return [{
-								type: 'files'
-							}];
-						}
+						if (!schemas[idx]) {
+
+							if (!(args[idx] || '').startsWith('-')) {
+								continue;
+							}
 
-						let key = current;
+							const [keyPath, schema] = allKeyPaths
+								.filter((keyPath) => !spent.includes(keyPath))
+								.map((keyPath) => [keyPath, keyPaths(options.schema).get(keyPath)])
+								.filter(([keyPath, schema]) => keyPath === args[idx] || `--${caseit(keyPath, 'kebab')}` === args[idx] || (schema.short && `-${schema.short}` === args[idx]))[0] || [];
+
+							if (schema && schema.type !== Array) {
+								spent.push(keyPath);
+							}
+
+							if (schema && schema.type !== Boolean) {
+								schemas[idx + 1] = schema;
+							}
 
-						while (key.startsWith('-')) {
-							key = key.slice(1);
 						}
 
-						key = caseit(key);
+					}
 
-						if (schemas[autocompleteIndex]) {
+					let current = args[autocompleteIndex] || '';
 
-							if (schemas[autocompleteIndex].enum) {
-								return Object.keys(schemas[autocompleteIndex].enum)
-									.map((item) => ({
-										type: 'option',
-										argument: caseit(item, 'kebab')
-									}));
-							}
+					while (current.startsWith('-')) {
+						current = current.slice(1);
+					}
 
-							if (schemas[autocompleteIndex].type === String && !schemas[autocompleteIndex].autocomplete) {
-								return [{
-									type: 'files'
-								}];
-							}
+					if (schemas[autocompleteIndex]) {
 
-							return await schemas[autocompleteIndex].autocomplete?.(current) || [];
+						if (schemas[autocompleteIndex].enum) {
+							output(Object.keys(schemas[autocompleteIndex].enum)
+								.map((item) => ({
+									type: 'option',
+									argument: caseit(item, 'kebab')
+								})));
+						}
 
-						} else {
+						if (schemas[autocompleteIndex].type === String && !schemas[autocompleteIndex].autocomplete) {
+							output([{
+								type: 'files'
+							}]);
+						}
 
-							let items = [];
+						let autocomplete = [];
 
-							if (variadic === 'allow') {
-								items = items.concat(
-									await autocomplete?.(current) || []);
+						if (typeof schemas[autocompleteIndex].autocomplete !== 'undefined') {
+							autocomplete = schemas[autocompleteIndex].autocomplete;
+							if (typeof autocomplete === 'function') {
+								autocomplete = await autocomplete(current);
 							}
+						}
 
-							if (!current.startsWith('--')) {
+						output(
+							autocomplete);
 
-								items = items.concat(
-									allKeyPaths
-										.filter((keyPath) => keyPaths(options.schema).get(keyPath).short)
-										.filter((keyPath) => !spent.includes(keyPath))
-										.map((keyPath) => ({
-											type: 'option',
-											argument: `-${caseit(keyPaths(options.schema).get(keyPath).short, 'kebab')}`,
-											description: keyPaths(options.schema).get(keyPath).description
-										})));
+					} else {
 
-							}
+						let items = [];
+
+						if (variadic === 'allow') {
+							items = items.concat(
+								await autocomplete?.(current) || []);
+						}
 
+						if (!current.startsWith('--')) {
 
 							items = items.concat(
 								allKeyPaths
+									.filter((keyPath) => keyPaths(options.schema).get(keyPath).short)
 									.filter((keyPath) => !spent.includes(keyPath))
 									.map((keyPath) => ({
 										type: 'option',
-										argument: `--${caseit(keyPath, 'kebab')}`,
+										argument: `-${caseit(keyPaths(options.schema).get(keyPath).short, 'kebab')}`,
 										description: keyPaths(options.schema).get(keyPath).description
 									})));
 
-							return items;
-
 						}
 
-					};
-
-					for (idx = 0; idx < autocompleteIndex || idx < args.length; idx++) {
-
-						if (!schemas[idx]) {
-
-							if (nonOptions || !(args[idx] || '').startsWith('-')) {
-								continue;
-							}
-
-							const [keyPath, schema] = allKeyPaths
+						items = items.concat(
+							allKeyPaths
 								.filter((keyPath) => !spent.includes(keyPath))
-								.map((keyPath) => [keyPath, keyPaths(options.schema).get(keyPath)])
-								.filter(([keyPath, schema]) => keyPath === args[idx] || `--${caseit(keyPath, 'kebab')}` === args[idx] || (schema.short && `-${schema.short}` === args[idx]))[0] || [];
-
-							if (schema && schema.type !== Array) {
-								spent.push(keyPath);
-							}
-
-							if (schema && schema.type !== Boolean) {
-								schemas[idx + 1] = schema;
-							}
+								.map((keyPath) => ({
+									type: 'option',
+									argument: `--${caseit(keyPath, 'kebab')}`,
+									description: keyPaths(options.schema).get(keyPath).description
+								})));
 
-						}
+						output(items);
 
 					}
 
-					return output(
-						await complete());
-
 				})().then(...resultArguments);
 			}
 		};

package/lib/autocomplete/zsh.js

@@ -46,8 +46,6 @@ const zsh = (items) => {
 
 		});
 
-	process.exit(0);
-
 };
 
 zsh.script = ({

package/lib/plugins/autocomplete.js

@@ -15,9 +15,41 @@ export default () => ({
 	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.');
-		}
+		if (!Array.isArray(data)) data = [data];
+
+		data
+			.forEach((item) => {
+
+				if (typeof item === 'string') {
+					item = {
+						type: 'option',
+						argument: item
+					};
+				}
+
+				if (typeof item?.type !== 'string') {
+					throw new Error('Autocomplete item must have a type.');
+				}
+
+				if (!['command', 'option', 'files'].includes(item.type)) {
+					throw new Error('Autocomplete item type must be one of: command, option, files.');
+				}
+
+				if (item.type !== 'files') {
+
+					if (typeof item?.argument !== 'string') {
+						throw new Error('Autocomplete item must have an argument.');
+					}
+
+					if (typeof item?.description !== 'undefined' && typeof item?.description !== 'string') {
+						throw new Error('Autocomplete item description must be a string.');
+					}
+
+				}
+
+				return item;
+
+			});
 
 		return data;
 

package/package.json

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