citty 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+const scule = require('scule');
 const tty = require('tty');
 
 function _interopNamespaceDefault(e) {
@@ -180,23 +181,30 @@ function parseArgs(rawArgs, argsDef) {
     }
   }
   const parsed = parseRawArgs(rawArgs, parseOptions);
-  for (const [i, arg] of args.entries()) {
+  const [, ...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, {
+    get(target, prop) {
+      return target[prop] ?? target[scule.camelCase(prop)] ?? target[scule.kebabCase(prop)];
+    }
+  });
+  for (const [, arg] of args.entries()) {
     if (arg.type === "positional") {
-      if (parsed._[i] !== void 0) {
-        parsed[arg.name] = parsed._[i];
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== void 0) {
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
       } else if (arg.default !== void 0) {
-        parsed[arg.name] = arg.default;
+        parsedArgsProxy[arg.name] = arg.default;
       } else {
         throw new CLIError(
           `Missing required positional argument: ${arg.name.toUpperCase()}`,
           "EARG"
         );
       }
-    } else if (arg.required && parsed[arg.name] === void 0) {
+    } else if (arg.required && parsedArgsProxy[arg.name] === void 0) {
       throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
     }
   }
-  return parsed;
+  return parsedArgsProxy;
 }
 function resolveArgs(argsDef) {
   const args = [];
@@ -214,17 +222,18 @@ function defineCommand(def) {
   return def;
 }
 async function runCommand(cmd, opts) {
-  if (typeof cmd.run === "function") {
-    const cmdArgs = await resolveValue(cmd.args || {});
-    const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
-    await cmd.run({
-      rawArgs: opts.rawArgs,
-      args: parsedArgs,
-      cmd
-    });
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    cmd
+  };
+  if (typeof cmd.setup === "function") {
+    await cmd.setup(context);
   }
   const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands.length > 0)) {
+  if (subCommands && Object.keys(subCommands).length > 0) {
     const subCommandArgIndex = opts.rawArgs.findIndex(
       (arg) => !arg.startsWith("-")
     );
@@ -248,10 +257,13 @@ async function runCommand(cmd, opts) {
       });
     }
   }
+  if (typeof cmd.run === "function") {
+    await cmd.run(context);
+  }
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
   const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands.length > 0)) {
+  if (subCommands && Object.keys(subCommands).length > 0) {
     const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
     const subCommandName = rawArgs[subCommandArgIndex];
     const subCommand = await resolveValue(subCommands[subCommandName]);

package/dist/index.d.ts

@@ -16,31 +16,45 @@ type Arg = ArgDef & {
     name: string;
     alias: string[];
 };
-type ParsedArgs = Record<string, string | boolean> & {
+type ParsedArgs<T extends ArgsDef = ArgsDef> = {
     _: string[];
-};
+} & Record<{
+    [K in keyof T]: T[K] extends {
+        type: "positional";
+    } ? K : never;
+}[keyof T], string | boolean> & Record<{
+    [K in keyof T]: T[K] extends {
+        type: "string";
+    } ? K : never;
+}[keyof T], string> & Record<{
+    [K in keyof T]: T[K] extends {
+        type: "boolean";
+    } ? K : never;
+}[keyof T], boolean>;
 interface CommandMeta {
     name?: string;
     version?: string;
     description?: string;
 }
-type SubCommandsDef = Record<string, Resolvable<CommandDef>>;
-type CommandDef = {
+type SubCommandsDef = Record<string, Resolvable<CommandDef<any>>>;
+type CommandDef<T extends ArgsDef = ArgsDef> = {
     meta?: Resolvable<CommandMeta>;
-    args?: Resolvable<ArgsDef>;
+    args?: Resolvable<T>;
     subCommands?: Resolvable<SubCommandsDef>;
-    run?: CommandRun;
+    setup?: (context: CommandContext<T>) => any | Promise<any>;
+    cleanup?: (context: CommandContext<T>) => any | Promise<any>;
+    run?: (context: CommandContext<T>) => any | Promise<any>;
 };
-type CommandRun = (context: CommandContext) => any | Promise<any>;
-interface CommandContext {
+type CommandContext<T extends ArgsDef = ArgsDef> = {
     rawArgs: string[];
-    args: ParsedArgs;
+    args: ParsedArgs<T>;
     cmd: CommandDef;
-}
+    subCommand?: CommandDef<T>;
+};
 type Awaitable<T> = () => T | Promise<T>;
 type Resolvable<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
 
-declare function defineCommand(def: CommandDef): CommandDef;
+declare function defineCommand<T extends ArgsDef = ArgsDef>(def: CommandDef<T>): CommandDef<T>;
 interface RunCommandOptions {
     rawArgs: string[];
     showUsage?: boolean;
@@ -57,4 +71,4 @@ declare function parseArgs(rawArgs: string[], argsDef: ArgsDef): ParsedArgs;
 declare function showUsage(cmd: CommandDef, parent?: CommandDef): Promise<void>;
 declare function renderUsage(cmd: CommandDef, parent?: CommandDef): Promise<string>;
 
-export { Arg, ArgDef, ArgType, ArgsDef, Awaitable, BooleanArgDef, CommandContext, CommandDef, CommandMeta, CommandRun, ParsedArgs, PositionalArgDef, Resolvable, RunCommandOptions, RunMainOptions, StringArgDef, SubCommandsDef, _ArgDef, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage };
+export { Arg, ArgDef, ArgType, ArgsDef, Awaitable, BooleanArgDef, CommandContext, CommandDef, CommandMeta, ParsedArgs, PositionalArgDef, Resolvable, RunCommandOptions, RunMainOptions, StringArgDef, SubCommandsDef, _ArgDef, defineCommand, parseArgs, renderUsage, runCommand, runMain, showUsage };

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { camelCase, kebabCase } from 'scule';
 import * as tty from 'tty';
 
 function toArray(val) {
@@ -165,23 +166,30 @@ function parseArgs(rawArgs, argsDef) {
     }
   }
   const parsed = parseRawArgs(rawArgs, parseOptions);
-  for (const [i, arg] of args.entries()) {
+  const [, ...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, {
+    get(target, prop) {
+      return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+    }
+  });
+  for (const [, arg] of args.entries()) {
     if (arg.type === "positional") {
-      if (parsed._[i] !== void 0) {
-        parsed[arg.name] = parsed._[i];
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== void 0) {
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
       } else if (arg.default !== void 0) {
-        parsed[arg.name] = arg.default;
+        parsedArgsProxy[arg.name] = arg.default;
       } else {
         throw new CLIError(
           `Missing required positional argument: ${arg.name.toUpperCase()}`,
           "EARG"
         );
       }
-    } else if (arg.required && parsed[arg.name] === void 0) {
+    } else if (arg.required && parsedArgsProxy[arg.name] === void 0) {
       throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
     }
   }
-  return parsed;
+  return parsedArgsProxy;
 }
 function resolveArgs(argsDef) {
   const args = [];
@@ -199,17 +207,18 @@ function defineCommand(def) {
   return def;
 }
 async function runCommand(cmd, opts) {
-  if (typeof cmd.run === "function") {
-    const cmdArgs = await resolveValue(cmd.args || {});
-    const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
-    await cmd.run({
-      rawArgs: opts.rawArgs,
-      args: parsedArgs,
-      cmd
-    });
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    cmd
+  };
+  if (typeof cmd.setup === "function") {
+    await cmd.setup(context);
   }
   const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands.length > 0)) {
+  if (subCommands && Object.keys(subCommands).length > 0) {
     const subCommandArgIndex = opts.rawArgs.findIndex(
       (arg) => !arg.startsWith("-")
     );
@@ -233,10 +242,13 @@ async function runCommand(cmd, opts) {
       });
     }
   }
+  if (typeof cmd.run === "function") {
+    await cmd.run(context);
+  }
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
   const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands.length > 0)) {
+  if (subCommands && Object.keys(subCommands).length > 0) {
     const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
     const subCommandName = rawArgs[subCommandArgIndex];
     const subCommand = await resolveValue(subCommands[subCommandName]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "citty",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Elegant CLI Builder",
   "repository": "unjs/citty",
   "license": "MIT",
@@ -29,18 +29,21 @@
     "release": "pnpm test && changelogen --release --push && npm publish",
     "test": "pnpm lint && vitest run --coverage"
   },
+  "dependencies": {
+    "scule": "^1.0.0"
+  },
   "devDependencies": {
-    "@types/node": "^18.15.3",
-    "@vitest/coverage-c8": "^0.29.2",
-    "changelogen": "^0.5.1",
+    "@types/node": "^18.15.10",
+    "@vitest/coverage-c8": "^0.29.8",
+    "changelogen": "^0.5.2",
     "colorette": "^2.0.19",
     "eslint": "^8.36.0",
     "eslint-config-unjs": "^0.1.0",
-    "jiti": "^1.17.2",
-    "prettier": "^2.8.4",
-    "typescript": "^4.9.5",
+    "jiti": "^1.18.2",
+    "prettier": "^2.8.7",
+    "typescript": "^5.0.2",
     "unbuild": "^1.1.2",
-    "vitest": "^0.29.2"
+    "vitest": "^0.29.8"
   },
-  "packageManager": "pnpm@7.25.1"
-}
+  "packageManager": "pnpm@8.0.0"
+}