feat(ucmd): finish parse method

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

.changeset/eighty-wasps-hug.md

@@ -0,0 +1,5 @@
+---
+"ucmd": patch
+---
+
+finish parse function

packages/ucmd/lib/index.test.ts

@@ -2,6 +2,61 @@ import { describe, expect, test } from "vitest";
 import { createCommand, ucmd } from ".";
 import type { CommandContext, Command } from ".";
 
+describe("parse commands", () => {
+	test("ucmd", () => {
+		let x = ucmd("example")
+			.withBaseCommand({
+				args: {
+					foo: true,
+					bar: false,
+				},
+			})
+			.withCommand({
+				name: "build",
+				args: {
+					test: {
+						type: "string",
+						default: "test",
+					},
+					foo: true,
+					bar: false,
+				},
+			});
+
+		expect(x.parse(["build", "test1", "--foo", "--test", "test", "test2"])).toMatchInlineSnapshot(`
+			{
+			  "res": {
+			    "positionals": [
+			      "test1",
+			      "test2",
+			    ],
+			    "values": {
+			      "foo": true,
+			      "test": "test",
+			    },
+			  },
+			  "run": [Function],
+			}
+		`);
+
+		expect(x.parse(["test1", "--foo", "test", "test2"])).toMatchInlineSnapshot(`
+			{
+			  "res": {
+			    "positionals": [
+			      "test1",
+			      "test",
+			      "test2",
+			    ],
+			    "values": {
+			      "foo": true,
+			    },
+			  },
+			  "run": [Function],
+			}
+		`);
+	});
+});
+
 describe("basic api", () => {
 	test("ucmd", () => {
 		let x = ucmd("example");
@@ -39,7 +94,8 @@ describe("basic api", () => {
 			name: "build",
 			args: {
 				foo: true,
-				bar: false,
+				bar: {},
+				baz: false,
 			},
 		});
 
@@ -48,7 +104,8 @@ describe("basic api", () => {
 			name: "build",
 			args: {
 				foo: true,
-				bar: false,
+				bar: {},
+				baz: false,
 			},
 		};
 

packages/ucmd/lib/index.ts

@@ -2,6 +2,7 @@ import { parseArgs } from "node:util";
 
 import type {
 	AddCommand,
+	BaseCommand,
 	Command,
 	CommandArgs,
 	CommandContext,
@@ -10,7 +11,7 @@ import type {
 	LiteralString,
 	ucmdState,
 } from "./types";
-import { generateOptions, toCommandArgs, CommandArg } from "./utils";
+import { normalizeCommandArgs, NormalizedCommandArg, toParseArgOptions } from "./utils";
 
 const defaultState: ucmdState<{}> = {
 	name: "",
@@ -43,16 +44,19 @@ class UCMD<TCommands extends CommandsLike, TBaseCommand> {
 	>(
 		command:
 			| LiteralString<TNewCommandName>
-			| Partial<Command<TNewCommandArgs, LiteralString<TNewCommandName>>>
-			| Command<TNewCommandArgs, LiteralString<TNewCommandName>>,
+			| Command<TNewCommandArgs, LiteralString<TNewCommandName>>
+			| Partial<Command<TNewCommandArgs, LiteralString<TNewCommandName>>>,
 		run?: CommandFn<TNewCommandArgs extends infer T ? T : never>,
 	): UCMD<TUpdatedCommands, TBaseCommand> {
 		let newCMD = createCommand(command, run);
 		Object.assign(this.#state.commands, { [newCMD.name]: newCMD });
 		return this as unknown as UCMD<TUpdatedCommands, TBaseCommand>;
 	}
 
-	withBaseCommand<TNewBaseCommand extends Command<CommandArgs, string>>(): UCMD<TCommands, TNewBaseCommand> {
+	withBaseCommand<TNewBaseCommand extends BaseCommand<CommandArgs>>(
+		baseCommand: TNewBaseCommand,
+	): UCMD<TCommands, TNewBaseCommand> {
+		(this.#state as unknown as { baseCommand: TNewBaseCommand }).baseCommand = baseCommand;
 		return this as unknown as UCMD<TCommands, TNewBaseCommand>;
 	}
 
@@ -61,34 +65,32 @@ class UCMD<TCommands extends CommandsLike, TBaseCommand> {
 
 		let run: CommandFn<{}> = defaultCommand;
 		let commandArgs = args || process.argv.slice(2);
-		let command: string | undefined = undefined;
-		let options: CommandArg[] = [];
+		let command: string | undefined = commandArgs[0];
+		let options: NormalizedCommandArg[] = [];
 
 		// Get the command
-		if (commandArgs[0] && !commandArgs[0].startsWith("-")) {
-			command = commandArgs[0];
+		if (command && !command.startsWith("-") && this.#state.commands[command]) {
 			commandArgs = commandArgs.slice(1);
 
-			if (!this.#state.commands[command]) return console.log("Command not found. Try --help");
 			run = this.#state.commands[command]?.run ?? defaultCommand;
-			options = toCommandArgs(this.#state.commands?.[command]?.args || []);
+			options = normalizeCommandArgs(this.#state.commands?.[command]?.args || []);
 		}
 
 		// If no command is specified, run the baseCommand
-		else if (!command) {
+		else {
 			if (!this.#state.baseCommand) {
 				console.log("No command specified");
 				return;
 			}
 
 			run = this.#state.baseCommand.run ?? defaultCommand;
-			options = toCommandArgs(this.#state.baseCommand.args || []);
-			return;
+			options = normalizeCommandArgs(this.#state.baseCommand.args || []);
 		}
 
 		let res = parseArgs({
 			args: commandArgs,
-			options: generateOptions(options),
+			allowPositionals: true,
+			options: toParseArgOptions(options),
 		});
 
 		return { res, run };
@@ -103,7 +105,6 @@ class UCMD<TCommands extends CommandsLike, TBaseCommand> {
 }
 
 export const ucmd = <T extends string>(name: T) => {
-	console.log(name);
 	return new UCMD().withName(name);
 };
 

packages/ucmd/lib/types.ts

@@ -9,14 +9,14 @@ export type CommandArgOptions = {
 	multiple?: boolean | undefined;
 };
 
-export type CommandArgs<TCommandArgs extends Record<string, CommandArgOptions | true> = {}> = {
-	[key in keyof TCommandArgs]: CommandArgOptions | true;
+export type CommandArgs<TCommandArgs extends Record<string, CommandArgOptions | boolean> = {}> = {
+	[key in keyof TCommandArgs]: CommandArgOptions | boolean;
 };
 
 export type BaseCommand<TCommandArguments extends CommandArgs> = {
 	description?: string | undefined;
 	run?: CommandFn<TCommandArguments>;
-	args?: TCommandArguments | undefined;
+	args?: Record<string, CommandArgOptions | boolean> | TCommandArguments;
 };
 
 export type CommandLike = Command<CommandArgs, string>;

packages/ucmd/lib/utils.ts

@@ -1,43 +1,47 @@
-import type { CommandArgOptions, ParseArgsOptionConfig } from "./types";
+import type { CommandArgOptions, CommandArgs, ParseArgsOptionConfig } from "./types";
 
-export type CommandArg = string | [string, CommandArgOptions] | (CommandArgOptions & { name: string });
+export type NormalizedCommandArg = CommandArgOptions & { name: string };
 
-export const toCommandArgs = (args: Record<string, CommandArgOptions | true> | CommandArg[]): CommandArg[] => {
+export const normalizeCommandArgs = (args: CommandArgs | NormalizedCommandArg[]): NormalizedCommandArg[] => {
 	if (Array.isArray(args)) return args;
 
-	return Object.entries(args).map(([name, options]) => {
-		if (typeof options === "boolean") return name;
-		return {
-			name,
-			...options,
-		};
-	});
-};
-
-export const generateOptions = (options: CommandArg[]): Record<string, ParseArgsOptionConfig> => {
-	let opts = options.map((option) => {
-		if (typeof option === "string")
-			return {
-				[option]: toParseArgOptions({}),
-			};
-
-		if (Array.isArray(option))
-			return {
-				[option[0]]: toParseArgOptions(option[1]),
+	return Object.entries(args)
+		.map(([name, options]) => {
+			if (options === false) return undefined;
+			if (options === undefined || options === true) return { name };
+			if (options === null || typeof options !== "object") throw new Error(`Invalid command arg options for ${name}`);
+			let opts: CommandArgOptions = options;
+			return <NormalizedCommandArg>{
+				name,
+				...opts,
 			};
-
-		return {
-			[option.name]: toParseArgOptions(option),
-		};
-	});
-
-	return Object.assign({}, ...opts);
+		})
+		.filter((arg) => arg !== undefined) as NormalizedCommandArg[];
 };
 
-const toParseArgOptions = (options: CommandArgOptions): ParseArgsOptionConfig => {
-	return {
-		type: "string",
-		default: options.default,
-		short: options.short,
+export const toParseArgOptions = (options: NormalizedCommandArg[]): Record<string, ParseArgsOptionConfig> =>
+	Object.assign(
+		{},
+		...options.map((option) => ({
+			[option.name]: toParseArgOption(option),
+		})),
+	);
+
+const toParseArgOption = (options: CommandArgOptions): ParseArgsOptionConfig => {
+	let opt = <ParseArgsOptionConfig>{
+		type: "boolean",
 	};
+
+	if (options.default !== undefined) opt.default = options.default;
+	if (options.type !== undefined) {
+		if (options.type === "number") {
+			opt.type = "string";
+		} else {
+			opt.type = options.type;
+		}
+	}
+	if (options.short !== undefined) opt.short = options.short;
+	if (options.multiple !== undefined) opt.multiple = options.multiple;
+
+	return opt;
 };