@trenskow/arguments-parser 0.3.139 → 0.3.141

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

@@ -36,53 +36,6 @@ const autocomplete = () => {
 		process.exit(1);
 	}
 
-	const normalize = (items) => items
-		.map((item) => {
-
-			if (typeof item === 'string') {
-				return {
-					type: 'option',
-					argument: item
-				};
-			}
-
-			return item;
-
-		});
-
-	const filter = (items, current = '') => {
-		return normalize(items)
-			.filter((item) => {
-				switch (item.type) {
-					case 'option':
-						// fall through
-					case 'command':
-						return item.argument !== current && item.argument.startsWith(current);
-					default:
-						return true;
-				}
-			});
-	};
-
-	const output = (items) => writer(
-		normalize(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;
-
-			}, {}));
-
 	const argumentsParser = (
 		{
 			args = process.argv.slice(3),
@@ -126,6 +79,57 @@ const autocomplete = () => {
 
 		};
 
+		const normalize = (items) => items
+			.map((item) => {
+
+				if (typeof item === 'string') {
+					return {
+						type: 'option',
+						argument: item
+					};
+				}
+
+				return item;
+
+			});
+
+		const filter = (items) => normalize(items)
+			.filter((item) => {
+				switch (item.type) {
+					case 'option':
+						// fall through
+					case 'command':
+						return item.argument !== args[autocompleteIndex] && item.argument.startsWith(args[autocompleteIndex]);
+					default:
+						return true;
+				}
+			});
+
+		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;
+
+					}, {}));
+
+			process.exit(0);
+
+		};
+
 		const result = {
 			get base() {
 				return base;
@@ -137,7 +141,6 @@ const autocomplete = () => {
 				if (autocompleteIndex === 0) {
 
 					return output(Object.keys(commands)
-						.filter((command) => command.startsWith(tool))
 						.map((command) => ({
 							type: 'command',
 							argument: caseit(command, 'kebab'),
@@ -166,8 +169,7 @@ const autocomplete = () => {
 
 				if (autocompleteIndex === 0) {
 					return output(
-						filter(
-							await autocomplete?.(args[0] || '') || [], args[0]));
+						await autocomplete?.(args[0] || '') || [], args[0]);
 				}
 
 				parameters[identifier] = args[0];
@@ -206,9 +208,14 @@ const autocomplete = () => {
 						}]
 					} = options.validationOptions;
 
-					const variadicOnly = args
+					if (args
 						.slice(0, autocompleteIndex)
-						.some((arg) => arg === '--');
+						.some((arg) => arg === '--')
+					) {
+						output([{
+							type: 'files'
+						}]);
+					}
 
 					const allKeyPaths = keyPaths(options.schema)
 						.all()
@@ -218,114 +225,92 @@ const autocomplete = () => {
 					let schemas = {};
 					let spent = [];
 
-					const complete = async (idx, current = '') => {
-
-						let key = current;
+					for (idx = 0; idx < autocompleteIndex || idx < args.length; idx++) {
 
-						while (key.startsWith('-')) {
-							key = key.slice(1);
-						}
+						if (!schemas[idx]) {
 
-						key = caseit(key);
+							if (!(args[idx] || '').startsWith('-')) {
+								continue;
+							}
 
-						if (!variadicOnly && schemas[idx]) {
+							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 (schemas[idx].enum) {
-								return Object.keys(schemas[idx].enum)
-									.filter((item) => key !== item && item.startsWith(current))
-									.map((item) => ({
-										type: 'option',
-										argument: caseit(item, 'kebab')
-									}));
+							if (schema && schema.type !== Array) {
+								spent.push(keyPath);
 							}
 
-							if (schemas[idx].type === String && !schemas[idx].autocomplete) {
-								return [{
-									type: 'files'
-								}];
+							if (schema && schema.type !== Boolean) {
+								schemas[idx + 1] = schema;
 							}
 
-							return filter(await schemas[idx].autocomplete?.(current) || [], current);
-
-						} else {
+						}
 
-							let items = [];
+					}
 
-							if (variadic === 'allow') {
-								items = items.concat(
-									filter(await autocomplete?.(current) || [], current));
-							}
+					let current = args[autocompleteIndex] || '';
 
-							if (!variadicOnly) {
+					while (current.startsWith('-')) {
+						current = current.slice(1);
+					}
 
-								if (!current.startsWith('--')) {
+					if (schemas[autocompleteIndex]) {
 
-									items = items.concat(
-										allKeyPaths
-											.filter((keyPath) => !spent.includes(keyPath))
-											.filter((keyPath) => key !== keyPath && keyPath.startsWith(key) && keyPaths(options.schema).get(keyPath).short)
-											.map((keyPath) => ({
-												type: 'option',
-												argument: `-${caseit(keyPaths(options.schema).get(keyPath).short, 'kebab')}`,
-												description: keyPaths(options.schema).get(keyPath).description
-											})));
+						if (schemas[autocompleteIndex].enum) {
+							output(Object.keys(schemas[autocompleteIndex].enum)
+								.map((item) => ({
+									type: 'option',
+									argument: caseit(item, 'kebab')
+								})));
+						}
 
-								}
+						if (schemas[autocompleteIndex].type === String && !schemas[autocompleteIndex].autocomplete) {
+							output([{
+								type: 'files'
+							}]);
+						}
 
+						output(
+							await schemas[autocompleteIndex].autocomplete?.(current) || []);
 
-								items = items.concat(
-									allKeyPaths
-										.filter((keyPath) => !spent.includes(keyPath))
-										.filter((keyPath) => key !== keyPath && keyPath.startsWith(key))
-										.map((keyPath) => ({
-											type: 'option',
-											argument: `--${caseit(keyPath, 'kebab')}`,
-											description: keyPaths(options.schema).get(keyPath).description
-										})));
+					} else {
 
-							}
-
-							if (variadic === 'allow' && !variadicOnly && current === Array(current.length).fill('-').join('')) {
-								items = items.concat([{
-									type: 'option',
-									argument: current.length ? '--'.slice(0, -current.length) : '--'
-								}]);
-							}
-
-							return items;
+						let items = [];
 
+						if (variadic === 'allow') {
+							items = items.concat(
+								await autocomplete?.(current) || []);
 						}
 
-					};
+						if (!current.startsWith('--')) {
 
-					for (idx = 0; idx < autocompleteIndex || idx < args.length; idx++) {
-
-						if (!schemas[idx]) {
+							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
+									})));
 
-							if (variadicOnly || !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(autocompleteIndex));
-
 				})().then(...resultArguments);
 			}
 		};

package/lib/autocomplete/zsh.js

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

package/package.json

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