clerc 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -12,7 +12,15 @@ class SingleCommandError extends Error {
     super("Single command mode enabled.");
   }
 }
+class SingleCommandAliasError extends Error {
+  constructor() {
+    super("Single command cannot have alias.");
+  }
+}
 class CommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" exists.`);
+  }
 }
 class CommonCommandExistsError extends Error {
   constructor() {
@@ -34,32 +42,44 @@ class SubcommandExistsError extends Error {
     super(`Command "${name}" cannot exist with its subcommand`);
   }
 }
-
-const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  if (command.alias) {
-    const item = utils.mustArray(command.alias).map(utils.kebabCase);
-    acc[utils.kebabCase(name)] = item;
+class MultipleCommandsMatchedError extends Error {
+  constructor(name) {
+    super(`Multiple commands matched: ${name}`);
   }
-  return acc;
-}, {});
-const resolveFlagDefault = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  const item = command.default;
-  if (item) {
-    acc[name] = item;
+}
+class CommandNameConflictError extends Error {
+  constructor(n1, n2) {
+    super(`Command name ${n1} conflicts with ${n2}. Maybe caused by alias.`);
   }
-  return acc;
-}, {});
+}
+
 function resolveCommand(commands, name) {
   if (name === SingleCommand) {
     return commands[SingleCommand];
   }
-  const nameArr = Array.isArray(name) ? name : name.split(" ");
-  const nameString = nameArr.join(" ");
-  const possibleCommands = Object.values(commands).filter(
-    (c) => utils.arrayStartsWith(nameArr, c.name.split(" ")) || utils.mustArray(c.alias || []).map(String).includes(nameString)
-  );
+  const nameArr = utils.mustArray(name);
+  const commandsMap = /* @__PURE__ */ new Map();
+  for (const command of Object.values(commands)) {
+    if (command.alias) {
+      const aliases = utils.mustArray(command.alias);
+      for (const alias of aliases) {
+        if (alias in commands) {
+          throw new CommandNameConflictError(commands[alias].name, command.name);
+        }
+        commandsMap.set(alias.split(" "), command);
+      }
+    }
+    commandsMap.set(command.name.split(" "), command);
+  }
+  const possibleCommands = [];
+  commandsMap.forEach((v, k) => {
+    if (utils.arrayStartsWith(nameArr, k)) {
+      possibleCommands.push(v);
+    }
+  });
   if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${nameString}"`);
+    const matchedCommandNames = possibleCommands.map((c) => c.name).join(", ");
+    throw new MultipleCommandsMatchedError(matchedCommandNames);
   }
   return possibleCommands[0];
 }
@@ -71,7 +91,10 @@ function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
   });
 }
 const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
-function resolveParametersBeforeFlag(argv) {
+function resolveParametersBeforeFlag(argv, isSingleCommand) {
+  if (isSingleCommand) {
+    return [];
+  }
   const parameters = [];
   for (const arg of argv) {
     if (arg.startsWith("-")) {
@@ -92,6 +115,65 @@ function compose(inspectors) {
   };
 }
 
+const { stringify } = JSON;
+function parseParameters(parameters) {
+  const parsedParameters = [];
+  let hasOptional;
+  let hasSpread;
+  for (const parameter of parameters) {
+    if (hasSpread) {
+      throw new Error(`Invalid parameter: Spread parameter ${stringify(hasSpread)} must be last`);
+    }
+    const firstCharacter = parameter[0];
+    const lastCharacter = parameter[parameter.length - 1];
+    let required;
+    if (firstCharacter === "<" && lastCharacter === ">") {
+      required = true;
+      if (hasOptional) {
+        throw new Error(`Invalid parameter: Required parameter ${stringify(parameter)} cannot come after optional parameter ${stringify(hasOptional)}`);
+      }
+    }
+    if (firstCharacter === "[" && lastCharacter === "]") {
+      required = false;
+      hasOptional = parameter;
+    }
+    if (required === void 0) {
+      throw new Error(`Invalid parameter: ${stringify(parameter)}. Must be wrapped in <> (required parameter) or [] (optional parameter)`);
+    }
+    let name = parameter.slice(1, -1);
+    const spread = name.slice(-3) === "...";
+    if (spread) {
+      hasSpread = parameter;
+      name = name.slice(0, -3);
+    }
+    parsedParameters.push({
+      name,
+      required,
+      spread
+    });
+  }
+  return parsedParameters;
+}
+function mapParametersToArguments(mapping, parameters, cliArguments) {
+  for (let i = 0; i < parameters.length; i += 1) {
+    const { name, required, spread } = parameters[i];
+    const camelCaseName = utils.camelCase(name);
+    if (camelCaseName in mapping) {
+      throw new Error(`Invalid parameter: ${stringify(name)} is used more than once.`);
+    }
+    const value = spread ? cliArguments.slice(i) : cliArguments[i];
+    if (spread) {
+      i = parameters.length;
+    }
+    if (required && (!value || spread && value.length === 0)) {
+      console.error(`Error: Missing required parameter ${stringify(name)}
+`);
+      return process.exit(1);
+    }
+    mapping[camelCaseName] = value;
+  }
+}
+
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -153,12 +235,14 @@ const _Clerc = class {
     __privateSet(this, _version, version);
     return this;
   }
-  command(name, description, options = {}) {
+  command(nameOrCommand, description, options) {
+    const checkIsCommandObject = (nameOrCommand2) => !(typeof nameOrCommand2 === "string" || nameOrCommand2 === SingleCommand);
+    const isCommandObject = checkIsCommandObject(nameOrCommand);
+    const name = !isCommandObject ? nameOrCommand : nameOrCommand.name;
     if (__privateGet(this, _commands)[name]) {
       if (name === SingleCommand) {
-        throw new CommandExistsError("Single command already exists");
+        throw new CommandExistsError("SingleCommand");
       }
-      throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
     }
     if (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
       throw new SingleCommandError();
@@ -166,6 +250,9 @@ const _Clerc = class {
     if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
       throw new CommonCommandExistsError();
     }
+    if (name === SingleCommand && (isCommandObject ? nameOrCommand : options).alias) {
+      throw new SingleCommandAliasError();
+    }
     if (name !== SingleCommand) {
       const splitedName = name.split(" ");
       const existedCommandNames = Object.keys(__privateGet(this, _commands)).filter((name2) => typeof name2 === "string").map((name2) => name2.split(" "));
@@ -176,7 +263,10 @@ const _Clerc = class {
         throw new SubcommandExistsError(splitedName.join(" "));
       }
     }
-    __privateGet(this, _commands)[name] = { name, description, ...options };
+    __privateGet(this, _commands)[name] = !isCommandObject ? { name, description, ...options } : nameOrCommand;
+    if (isCommandObject && nameOrCommand.handler) {
+      this.on(nameOrCommand.name, nameOrCommand.handler);
+    }
     return this;
   }
   on(name, handler) {
@@ -191,23 +281,48 @@ const _Clerc = class {
     return this;
   }
   parse(argv = resolveArgv()) {
-    const name = resolveParametersBeforeFlag(argv);
+    const name = resolveParametersBeforeFlag(argv, __privateGet(this, _isSingleCommand, isSingleCommand_get));
     const stringName = name.join(" ");
     const getCommand = () => __privateGet(this, _isSingleCommand, isSingleCommand_get) ? __privateGet(this, _commands)[SingleCommand] : resolveCommand(__privateGet(this, _commands), name);
     const getContext = () => {
       const command = getCommand();
       const isCommandResolved = !!command;
-      const parsedWithType = typeFlag.typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
-      const { _: args, flags } = parsedWithType;
-      const parameters = __privateGet(this, _isSingleCommand, isSingleCommand_get) || !isCommandResolved ? args : args.slice(command.name.split(" ").length);
+      const parsed = typeFlag.typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
+      const { _: args, flags } = parsed;
+      let parameters = __privateGet(this, _isSingleCommand, isSingleCommand_get) || !isCommandResolved ? args : args.slice(command.name.split(" ").length);
+      let commandParameters = (command == null ? void 0 : command.parameters) || [];
+      const hasEof = commandParameters.indexOf("--");
+      const eofParameters = commandParameters.slice(hasEof + 1) || [];
+      const mapping = /* @__PURE__ */ Object.create(null);
+      if (hasEof > -1 && eofParameters.length > 0) {
+        commandParameters = commandParameters.slice(0, hasEof);
+        const eofArguments = parsed._["--"];
+        parameters = parameters.slice(0, -eofArguments.length || void 0);
+        mapParametersToArguments(
+          mapping,
+          parseParameters(commandParameters),
+          parameters
+        );
+        mapParametersToArguments(
+          mapping,
+          parseParameters(eofParameters),
+          eofArguments
+        );
+      } else {
+        mapParametersToArguments(
+          mapping,
+          parseParameters(commandParameters),
+          parameters
+        );
+      }
       const context = {
         name: command == null ? void 0 : command.name,
         resolved: isCommandResolved,
         isSingleCommand: __privateGet(this, _isSingleCommand, isSingleCommand_get),
-        raw: parsedWithType,
-        parameters,
+        raw: parsed,
+        parameters: mapping,
         flags,
-        unknownFlags: parsedWithType.unknownFlags,
+        unknownFlags: parsed.unknownFlags,
         cli: this
       };
       return context;
@@ -245,23 +360,30 @@ hasCommands_get = function() {
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
+const defineCommand = (c) => c;
+const defineCommandWithHandler = (c) => c;
 
 exports.Clerc = Clerc;
 exports.CommandExistsError = CommandExistsError;
+exports.CommandNameConflictError = CommandNameConflictError;
 exports.CommonCommandExistsError = CommonCommandExistsError;
+exports.MultipleCommandsMatchedError = MultipleCommandsMatchedError;
 exports.NoSuchCommandError = NoSuchCommandError;
 exports.ParentCommandExistsError = ParentCommandExistsError;
 exports.SingleCommand = SingleCommand;
+exports.SingleCommandAliasError = SingleCommandAliasError;
 exports.SingleCommandError = SingleCommandError;
 exports.SubcommandExistsError = SubcommandExistsError;
 exports.compose = compose;
+exports.defineCommand = defineCommand;
+exports.defineCommandWithHandler = defineCommandWithHandler;
 exports.defineHandler = defineHandler;
 exports.defineInspector = defineInspector;
 exports.definePlugin = definePlugin;
+exports.mapParametersToArguments = mapParametersToArguments;
+exports.parseParameters = parseParameters;
 exports.resolveArgv = resolveArgv;
 exports.resolveCommand = resolveCommand;
-exports.resolveFlagAlias = resolveFlagAlias;
-exports.resolveFlagDefault = resolveFlagDefault;
 exports.resolveParametersBeforeFlag = resolveParametersBeforeFlag;
 exports.resolveRootCommands = resolveRootCommands;
 exports.resolveSubcommandsByParent = resolveSubcommandsByParent;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _clerc_utils from '@clerc/utils';
-import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
+import { MaybeArray, Dict, CamelCase, LiteralUnion } from '@clerc/utils';
 
 declare const DOUBLE_DASH = "--";
 type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
@@ -76,16 +76,22 @@ type FlagOptions = FlagSchema & {
 type Flag = FlagOptions & {
     name: string;
 };
-interface CommandOptions<A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
+interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
     alias?: A;
+    parameters?: P;
     flags?: F;
     examples?: [string, string][];
     notes?: string[];
 }
-type Command<N extends string | SingleCommandType = string, D extends string = string, Options extends CommandOptions = CommandOptions> = Options & {
+type Command<N extends string | SingleCommandType = string, D extends string = string, O extends CommandOptions = CommandOptions> = O & {
     name: N;
     description: D;
 };
+type CommandWithHandler<N extends string | SingleCommandType = string, D extends string = string, O extends CommandOptions = CommandOptions> = Command<N, D, O> & {
+    handler?: HandlerInCommand<Record<N, Command<N, D, O>>, N>;
+};
+type StripBrackets<Parameter extends string> = (Parameter extends `<${infer ParameterName}>` | `[${infer ParameterName}]` ? (ParameterName extends `${infer SpreadName}...` ? SpreadName : ParameterName) : never);
+type ParameterType<Parameter extends string> = (Parameter extends `<${infer _ParameterName}...>` | `[${infer _ParameterName}...]` ? string[] : Parameter extends `<${infer _ParameterName}>` ? string : Parameter extends `[${infer _ParameterName}]` ? string | undefined : never);
 type CommandRecord = Dict<Command> & {
     [SingleCommand]?: Command;
 };
@@ -94,17 +100,23 @@ type MakeEventMap<T extends CommandRecord> = {
 };
 type PossibleInputKind = string | number | boolean | Dict<any>;
 type NonNullableFlag<T extends Dict<FlagOptions> | undefined> = T extends undefined ? {} : NonNullable<T>;
+type NonNullableParameters<T extends string[] | undefined> = T extends undefined ? [] : NonNullable<T>;
 interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
     name?: N;
     resolved: boolean;
     isSingleCommand: boolean;
     raw: ParsedFlags;
-    parameters: PossibleInputKind[];
+    parameters: {
+        [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
+    };
     unknownFlags: ParsedFlags["unknownFlags"];
     flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
     cli: Clerc<C>;
 }
 type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
+type HandlerInCommand<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K> & {
+    name: K;
+}) => void;
 type FallbackType<T, U> = {} extends T ? U : T;
 type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
     flags: FallbackType<TypeFlag<NonNullableFlag<C[keyof C]["flags"]>>["flags"], Dict<any>>;
@@ -196,7 +208,8 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    command<N extends string | SingleCommandType, D extends string, O extends CommandOptions>(name: N, description: D, options?: O): this & Clerc<C & Record<N, Command<N, D, O>>>;
+    command<N extends string | SingleCommandType, D extends string, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, D, O>>>;
+    command<N extends string | SingleCommandType, D extends string, P extends string[], O extends CommandOptions<[...P]>>(name: N, description: D, options: O & CommandOptions<[...P]>): this & Clerc<C & Record<N, Command<N, D, O>>>;
     /**
      * Register a handler
      * @param name
@@ -252,12 +265,18 @@ declare class Clerc<C extends CommandRecord = {}> {
 
 declare const definePlugin: <T extends Clerc<{}>, U extends Clerc<{}>>(p: Plugin<T, U>) => Plugin<T, U>;
 declare const defineHandler: <C extends Clerc<{}>, K extends keyof C["_commands"]>(_cli: C, _key: K, handler: Handler<C["_commands"], K>) => Handler<C["_commands"], K>;
-declare const defineInspector: <C extends Clerc<{}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<C["_commands"]>;
+declare const defineInspector: <C extends Clerc<{}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<C["_commands"]>;
+declare const defineCommand: <N extends string | typeof SingleCommand, D extends string, P extends string[], O extends CommandOptions<[...P], MaybeArray<string>, Dict<FlagOptions>>>(c: Command<N, D, O>) => Command<N, D, O>;
+declare const defineCommandWithHandler: <N extends string | typeof SingleCommand, D extends string, O extends CommandOptions<[...P], A, F>, P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>>(c: CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>) => CommandWithHandler<N, D, O & CommandOptions<[...P], A, F>>;
 
 declare class SingleCommandError extends Error {
     constructor();
 }
+declare class SingleCommandAliasError extends Error {
+    constructor();
+}
 declare class CommandExistsError extends Error {
+    constructor(name: string);
 }
 declare class CommonCommandExistsError extends Error {
     constructor();
@@ -270,15 +289,27 @@ declare class ParentCommandExistsError extends Error {
 }
 declare class SubcommandExistsError extends Error {
     constructor(name: string);
+}
+declare class MultipleCommandsMatchedError extends Error {
+    constructor(name: string);
+}
+declare class CommandNameConflictError extends Error {
+    constructor(n1: string, n2: string);
 }
 
-declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
-declare const resolveFlagDefault: (_command: Command) => Dict<any>;
 declare function resolveCommand(commands: CommandRecord, name: string | string[] | SingleCommandType): Command | undefined;
-declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, string, CommandOptions<_clerc_utils.MaybeArray<string>, Dict<FlagOptions>>>[];
-declare const resolveRootCommands: (commands: CommandRecord) => Command<string, string, CommandOptions<_clerc_utils.MaybeArray<string>, Dict<FlagOptions>>>[];
-declare function resolveParametersBeforeFlag(argv: string[]): string[];
+declare function resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>[];
+declare const resolveRootCommands: (commands: CommandRecord) => Command<string, string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>[];
+declare function resolveParametersBeforeFlag(argv: string[], isSingleCommand: boolean): string[];
 declare const resolveArgv: () => string[];
 declare function compose(inspectors: Inspector[]): (getCtx: () => InspectorContext) => void;
 
-export { Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, MakeEventMap, NoSuchCommandError, ParentCommandExistsError, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, SubcommandExistsError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };
+interface ParsedParameter {
+    name: string;
+    required: boolean;
+    spread: boolean;
+}
+declare function parseParameters(parameters: string[]): ParsedParameter[];
+declare function mapParametersToArguments(mapping: Record<string, string | string[]>, parameters: ParsedParameter[], cliArguments: string[]): undefined;
+
+export { Clerc, Command, CommandExistsError, CommandNameConflictError, CommandOptions, CommandRecord, CommandWithHandler, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, HandlerInCommand, Inspector, InspectorContext, MakeEventMap, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, Plugin, PossibleInputKind, SingleCommand, SingleCommandAliasError, SingleCommandError, SingleCommandType, SubcommandExistsError, compose, defineCommand, defineCommandWithHandler, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { LiteEmit } from 'lite-emit';
 import { typeFlag } from 'type-flag';
-import { mustArray, kebabCase, arrayStartsWith } from '@clerc/utils';
+import { mustArray, arrayStartsWith, camelCase } from '@clerc/utils';
 import { isNode, isDeno } from 'is-platform';
 
 class SingleCommandError extends Error {
@@ -8,7 +8,15 @@ class SingleCommandError extends Error {
     super("Single command mode enabled.");
   }
 }
+class SingleCommandAliasError extends Error {
+  constructor() {
+    super("Single command cannot have alias.");
+  }
+}
 class CommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" exists.`);
+  }
 }
 class CommonCommandExistsError extends Error {
   constructor() {
@@ -30,32 +38,44 @@ class SubcommandExistsError extends Error {
     super(`Command "${name}" cannot exist with its subcommand`);
   }
 }
+class MultipleCommandsMatchedError extends Error {
+  constructor(name) {
+    super(`Multiple commands matched: ${name}`);
+  }
+}
+class CommandNameConflictError extends Error {
+  constructor(n1, n2) {
+    super(`Command name ${n1} conflicts with ${n2}. Maybe caused by alias.`);
+  }
+}
 
-const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  if (command.alias) {
-    const item = mustArray(command.alias).map(kebabCase);
-    acc[kebabCase(name)] = item;
-  }
-  return acc;
-}, {});
-const resolveFlagDefault = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
-  const item = command.default;
-  if (item) {
-    acc[name] = item;
-  }
-  return acc;
-}, {});
 function resolveCommand(commands, name) {
   if (name === SingleCommand) {
     return commands[SingleCommand];
   }
-  const nameArr = Array.isArray(name) ? name : name.split(" ");
-  const nameString = nameArr.join(" ");
-  const possibleCommands = Object.values(commands).filter(
-    (c) => arrayStartsWith(nameArr, c.name.split(" ")) || mustArray(c.alias || []).map(String).includes(nameString)
-  );
+  const nameArr = mustArray(name);
+  const commandsMap = /* @__PURE__ */ new Map();
+  for (const command of Object.values(commands)) {
+    if (command.alias) {
+      const aliases = mustArray(command.alias);
+      for (const alias of aliases) {
+        if (alias in commands) {
+          throw new CommandNameConflictError(commands[alias].name, command.name);
+        }
+        commandsMap.set(alias.split(" "), command);
+      }
+    }
+    commandsMap.set(command.name.split(" "), command);
+  }
+  const possibleCommands = [];
+  commandsMap.forEach((v, k) => {
+    if (arrayStartsWith(nameArr, k)) {
+      possibleCommands.push(v);
+    }
+  });
   if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${nameString}"`);
+    const matchedCommandNames = possibleCommands.map((c) => c.name).join(", ");
+    throw new MultipleCommandsMatchedError(matchedCommandNames);
   }
   return possibleCommands[0];
 }
@@ -67,7 +87,10 @@ function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
   });
 }
 const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
-function resolveParametersBeforeFlag(argv) {
+function resolveParametersBeforeFlag(argv, isSingleCommand) {
+  if (isSingleCommand) {
+    return [];
+  }
   const parameters = [];
   for (const arg of argv) {
     if (arg.startsWith("-")) {
@@ -88,6 +111,65 @@ function compose(inspectors) {
   };
 }
 
+const { stringify } = JSON;
+function parseParameters(parameters) {
+  const parsedParameters = [];
+  let hasOptional;
+  let hasSpread;
+  for (const parameter of parameters) {
+    if (hasSpread) {
+      throw new Error(`Invalid parameter: Spread parameter ${stringify(hasSpread)} must be last`);
+    }
+    const firstCharacter = parameter[0];
+    const lastCharacter = parameter[parameter.length - 1];
+    let required;
+    if (firstCharacter === "<" && lastCharacter === ">") {
+      required = true;
+      if (hasOptional) {
+        throw new Error(`Invalid parameter: Required parameter ${stringify(parameter)} cannot come after optional parameter ${stringify(hasOptional)}`);
+      }
+    }
+    if (firstCharacter === "[" && lastCharacter === "]") {
+      required = false;
+      hasOptional = parameter;
+    }
+    if (required === void 0) {
+      throw new Error(`Invalid parameter: ${stringify(parameter)}. Must be wrapped in <> (required parameter) or [] (optional parameter)`);
+    }
+    let name = parameter.slice(1, -1);
+    const spread = name.slice(-3) === "...";
+    if (spread) {
+      hasSpread = parameter;
+      name = name.slice(0, -3);
+    }
+    parsedParameters.push({
+      name,
+      required,
+      spread
+    });
+  }
+  return parsedParameters;
+}
+function mapParametersToArguments(mapping, parameters, cliArguments) {
+  for (let i = 0; i < parameters.length; i += 1) {
+    const { name, required, spread } = parameters[i];
+    const camelCaseName = camelCase(name);
+    if (camelCaseName in mapping) {
+      throw new Error(`Invalid parameter: ${stringify(name)} is used more than once.`);
+    }
+    const value = spread ? cliArguments.slice(i) : cliArguments[i];
+    if (spread) {
+      i = parameters.length;
+    }
+    if (required && (!value || spread && value.length === 0)) {
+      console.error(`Error: Missing required parameter ${stringify(name)}
+`);
+      return process.exit(1);
+    }
+    mapping[camelCaseName] = value;
+  }
+}
+
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -149,12 +231,14 @@ const _Clerc = class {
     __privateSet(this, _version, version);
     return this;
   }
-  command(name, description, options = {}) {
+  command(nameOrCommand, description, options) {
+    const checkIsCommandObject = (nameOrCommand2) => !(typeof nameOrCommand2 === "string" || nameOrCommand2 === SingleCommand);
+    const isCommandObject = checkIsCommandObject(nameOrCommand);
+    const name = !isCommandObject ? nameOrCommand : nameOrCommand.name;
     if (__privateGet(this, _commands)[name]) {
       if (name === SingleCommand) {
-        throw new CommandExistsError("Single command already exists");
+        throw new CommandExistsError("SingleCommand");
       }
-      throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
     }
     if (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
       throw new SingleCommandError();
@@ -162,6 +246,9 @@ const _Clerc = class {
     if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
       throw new CommonCommandExistsError();
     }
+    if (name === SingleCommand && (isCommandObject ? nameOrCommand : options).alias) {
+      throw new SingleCommandAliasError();
+    }
     if (name !== SingleCommand) {
       const splitedName = name.split(" ");
       const existedCommandNames = Object.keys(__privateGet(this, _commands)).filter((name2) => typeof name2 === "string").map((name2) => name2.split(" "));
@@ -172,7 +259,10 @@ const _Clerc = class {
         throw new SubcommandExistsError(splitedName.join(" "));
       }
     }
-    __privateGet(this, _commands)[name] = { name, description, ...options };
+    __privateGet(this, _commands)[name] = !isCommandObject ? { name, description, ...options } : nameOrCommand;
+    if (isCommandObject && nameOrCommand.handler) {
+      this.on(nameOrCommand.name, nameOrCommand.handler);
+    }
     return this;
   }
   on(name, handler) {
@@ -187,23 +277,48 @@ const _Clerc = class {
     return this;
   }
   parse(argv = resolveArgv()) {
-    const name = resolveParametersBeforeFlag(argv);
+    const name = resolveParametersBeforeFlag(argv, __privateGet(this, _isSingleCommand, isSingleCommand_get));
     const stringName = name.join(" ");
     const getCommand = () => __privateGet(this, _isSingleCommand, isSingleCommand_get) ? __privateGet(this, _commands)[SingleCommand] : resolveCommand(__privateGet(this, _commands), name);
     const getContext = () => {
       const command = getCommand();
       const isCommandResolved = !!command;
-      const parsedWithType = typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
-      const { _: args, flags } = parsedWithType;
-      const parameters = __privateGet(this, _isSingleCommand, isSingleCommand_get) || !isCommandResolved ? args : args.slice(command.name.split(" ").length);
+      const parsed = typeFlag((command == null ? void 0 : command.flags) || {}, [...argv]);
+      const { _: args, flags } = parsed;
+      let parameters = __privateGet(this, _isSingleCommand, isSingleCommand_get) || !isCommandResolved ? args : args.slice(command.name.split(" ").length);
+      let commandParameters = (command == null ? void 0 : command.parameters) || [];
+      const hasEof = commandParameters.indexOf("--");
+      const eofParameters = commandParameters.slice(hasEof + 1) || [];
+      const mapping = /* @__PURE__ */ Object.create(null);
+      if (hasEof > -1 && eofParameters.length > 0) {
+        commandParameters = commandParameters.slice(0, hasEof);
+        const eofArguments = parsed._["--"];
+        parameters = parameters.slice(0, -eofArguments.length || void 0);
+        mapParametersToArguments(
+          mapping,
+          parseParameters(commandParameters),
+          parameters
+        );
+        mapParametersToArguments(
+          mapping,
+          parseParameters(eofParameters),
+          eofArguments
+        );
+      } else {
+        mapParametersToArguments(
+          mapping,
+          parseParameters(commandParameters),
+          parameters
+        );
+      }
       const context = {
         name: command == null ? void 0 : command.name,
         resolved: isCommandResolved,
         isSingleCommand: __privateGet(this, _isSingleCommand, isSingleCommand_get),
-        raw: parsedWithType,
-        parameters,
+        raw: parsed,
+        parameters: mapping,
         flags,
-        unknownFlags: parsedWithType.unknownFlags,
+        unknownFlags: parsed.unknownFlags,
         cli: this
       };
       return context;
@@ -241,5 +356,7 @@ hasCommands_get = function() {
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
+const defineCommand = (c) => c;
+const defineCommandWithHandler = (c) => c;
 
-export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, ParentCommandExistsError, SingleCommand, SingleCommandError, SubcommandExistsError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };
+export { Clerc, CommandExistsError, CommandNameConflictError, CommonCommandExistsError, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, SingleCommand, SingleCommandAliasError, SingleCommandError, SubcommandExistsError, compose, defineCommand, defineCommandWithHandler, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "author": "Ray <nn_201312@163.com> (https://github.com/so1ve)",
   "description": "Clerc is a simple and easy-to-use cli framework.",
   "keywords": [
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@clerc/utils": "0.6.0",
+    "@clerc/utils": "0.7.0",
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "type-flag": "^3.0.0"