@trenskow/arguments-parser 0.3.139 → 0.3.140

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,51 @@ 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;
+
+				}, {}));
+
 		const result = {
 			get base() {
 				return base;
@@ -137,7 +135,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 +163,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,7 +202,7 @@ const autocomplete = () => {
 						}]
 					} = options.validationOptions;
 
-					const variadicOnly = args
+					const nonOptions = args
 						.slice(0, autocompleteIndex)
 						.some((arg) => arg === '--');
 
@@ -218,7 +214,13 @@ const autocomplete = () => {
 					let schemas = {};
 					let spent = [];
 
-					const complete = async (idx, current = '') => {
+					const complete = async (current = args[autocompleteIndex] || '') => {
+
+						if (nonOptions) {
+							return [{
+								type: 'files'
+							}];
+						}
 
 						let key = current;
 
@@ -228,24 +230,23 @@ const autocomplete = () => {
 
 						key = caseit(key);
 
-						if (!variadicOnly && schemas[idx]) {
+						if (schemas[autocompleteIndex]) {
 
-							if (schemas[idx].enum) {
-								return Object.keys(schemas[idx].enum)
-									.filter((item) => key !== item && item.startsWith(current))
+							if (schemas[autocompleteIndex].enum) {
+								return Object.keys(schemas[autocompleteIndex].enum)
 									.map((item) => ({
 										type: 'option',
 										argument: caseit(item, 'kebab')
 									}));
 							}
 
-							if (schemas[idx].type === String && !schemas[idx].autocomplete) {
+							if (schemas[autocompleteIndex].type === String && !schemas[autocompleteIndex].autocomplete) {
 								return [{
 									type: 'files'
 								}];
 							}
 
-							return filter(await schemas[idx].autocomplete?.(current) || [], current);
+							return await schemas[autocompleteIndex].autocomplete?.(current) || [];
 
 						} else {
 
@@ -253,44 +254,32 @@ const autocomplete = () => {
 
 							if (variadic === 'allow') {
 								items = items.concat(
-									filter(await autocomplete?.(current) || [], current));
+									await autocomplete?.(current) || []);
 							}
 
-							if (!variadicOnly) {
-
-								if (!current.startsWith('--')) {
-
-									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 (!current.startsWith('--')) {
 
 								items = items.concat(
 									allKeyPaths
+										.filter((keyPath) => keyPaths(options.schema).get(keyPath).short)
 										.filter((keyPath) => !spent.includes(keyPath))
-										.filter((keyPath) => key !== keyPath && keyPath.startsWith(key))
 										.map((keyPath) => ({
 											type: 'option',
-											argument: `--${caseit(keyPath, 'kebab')}`,
+											argument: `-${caseit(keyPaths(options.schema).get(keyPath).short, 'kebab')}`,
 											description: keyPaths(options.schema).get(keyPath).description
 										})));
 
 							}
 
-							if (variadic === 'allow' && !variadicOnly && current === Array(current.length).fill('-').join('')) {
-								items = items.concat([{
-									type: 'option',
-									argument: current.length ? '--'.slice(0, -current.length) : '--'
-								}]);
-							}
+
+							items = items.concat(
+								allKeyPaths
+									.filter((keyPath) => !spent.includes(keyPath))
+									.map((keyPath) => ({
+										type: 'option',
+										argument: `--${caseit(keyPath, 'kebab')}`,
+										description: keyPaths(options.schema).get(keyPath).description
+									})));
 
 							return items;
 
@@ -302,7 +291,7 @@ const autocomplete = () => {
 
 						if (!schemas[idx]) {
 
-							if (variadicOnly || !args[idx].startsWith('-')) {
+							if (nonOptions || !(args[idx] || '').startsWith('-')) {
 								continue;
 							}
 
@@ -324,7 +313,7 @@ const autocomplete = () => {
 					}
 
 					return output(
-						await complete(autocompleteIndex));
+						await complete());
 
 				})().then(...resultArguments);
 			}

package/package.json

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