clerc 0.7.0 → 0.8.1

package/dist/index.cjs

@@ -53,11 +53,7 @@ class CommandNameConflictError extends Error {
   }
 }
 
-function resolveCommand(commands, name) {
-  if (name === SingleCommand) {
-    return commands[SingleCommand];
-  }
-  const nameArr = utils.mustArray(name);
+function resolveFlattenCommands(commands) {
   const commandsMap = /* @__PURE__ */ new Map();
   for (const command of Object.values(commands)) {
     if (command.alias) {
@@ -66,11 +62,19 @@ function resolveCommand(commands, name) {
         if (alias in commands) {
           throw new CommandNameConflictError(commands[alias].name, command.name);
         }
-        commandsMap.set(alias.split(" "), command);
+        commandsMap.set(alias.split(" "), { ...command, __isAlias: true });
       }
     }
     commandsMap.set(command.name.split(" "), command);
   }
+  return commandsMap;
+}
+function resolveCommand(commands, name) {
+  if (name === SingleCommand) {
+    return commands[SingleCommand];
+  }
+  const nameArr = utils.mustArray(name);
+  const commandsMap = resolveFlattenCommands(commands);
   const possibleCommands = [];
   commandsMap.forEach((v, k) => {
     if (utils.arrayStartsWith(nameArr, k)) {
@@ -336,8 +340,8 @@ const _Clerc = class {
       __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
     const inspectors = [...__privateGet(this, _inspectors), emitHandler];
-    const inspector = compose(inspectors);
-    inspector(getContext);
+    const callInspector = compose(inspectors);
+    callInspector(getContext);
     return this;
   }
 };
@@ -384,6 +388,7 @@ exports.mapParametersToArguments = mapParametersToArguments;
 exports.parseParameters = parseParameters;
 exports.resolveArgv = resolveArgv;
 exports.resolveCommand = resolveCommand;
+exports.resolveFlattenCommands = resolveFlattenCommands;
 exports.resolveParametersBeforeFlag = resolveParametersBeforeFlag;
 exports.resolveRootCommands = resolveRootCommands;
 exports.resolveSubcommandsByParent = resolveSubcommandsByParent;

package/dist/index.d.ts

@@ -76,19 +76,24 @@ type FlagOptions = FlagSchema & {
 type Flag = FlagOptions & {
     name: string;
 };
-interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
+declare interface CommandCustomProperties {
+}
+interface CommandOptions<P extends string[] = string[], A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> extends CommandCustomProperties {
     alias?: A;
     parameters?: P;
     flags?: F;
     examples?: [string, string][];
     notes?: string[];
 }
-type Command<N extends string | SingleCommandType = string, D extends string = string, O extends CommandOptions = CommandOptions> = O & {
+type Command<N extends string | SingleCommandType = string, O extends CommandOptions = CommandOptions> = O & {
     name: N;
-    description: D;
+    description: string;
+};
+type CommandAlias<N extends string | SingleCommandType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
+    __isAlias?: true;
 };
-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 CommandWithHandler<N extends string | SingleCommandType = string, O extends CommandOptions = CommandOptions> = Command<N, O> & {
+    handler?: HandlerInCommand<Record<N, Command<N, 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);
@@ -105,7 +110,7 @@ interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyo
     name?: N;
     resolved: boolean;
     isSingleCommand: boolean;
-    raw: ParsedFlags;
+    raw: TypeFlag<NonNullableFlag<C[N]["flags"]>>;
     parameters: {
         [Parameter in [...NonNullableParameters<C[N]["parameters"]>][number] as CamelCase<StripBrackets<Parameter>>]: ParameterType<Parameter>;
     };
@@ -208,8 +213,8 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   })
      * ```
      */
-    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>>>;
+    command<N extends string | SingleCommandType, 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, O & CommandOptions<[...P], A, F>>): this & Clerc<C & Record<N, Command<N, O>>>;
+    command<N extends string | SingleCommandType, P extends string[], O extends CommandOptions<[...P]>>(name: N, description: string, options?: O & CommandOptions<[...P]>): this & Clerc<C & Record<N, Command<N, O>>>;
     /**
      * Register a handler
      * @param name
@@ -266,8 +271,8 @@ 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 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 const defineCommand: <N extends string | typeof SingleCommand, P extends string[], O extends CommandOptions<[...P], MaybeArray<string>, Dict<FlagOptions>>>(c: Command<N, O>) => Command<N, O>;
+declare const defineCommandWithHandler: <N extends string | typeof SingleCommand, 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, O & CommandOptions<[...P], A, F>>) => CommandWithHandler<N, O & CommandOptions<[...P], A, F>>;
 
 declare class SingleCommandError extends Error {
     constructor();
@@ -297,9 +302,10 @@ declare class CommandNameConflictError extends Error {
     constructor(n1: string, n2: string);
 }
 
+declare function resolveFlattenCommands(commands: CommandRecord): Map<string[], CommandAlias<string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>>;
 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<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 resolveSubcommandsByParent(commands: CommandRecord, parent: string | string[], depth?: number): Command<string, CommandOptions<string[], _clerc_utils.MaybeArray<string>, _clerc_utils.Dict<FlagOptions>>>[];
+declare const resolveRootCommands: (commands: CommandRecord) => Command<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;
@@ -312,4 +318,4 @@ interface ParsedParameter {
 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 };
+export { Clerc, Command, CommandAlias, CommandCustomProperties, 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, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/dist/index.mjs

@@ -49,11 +49,7 @@ class CommandNameConflictError extends Error {
   }
 }
 
-function resolveCommand(commands, name) {
-  if (name === SingleCommand) {
-    return commands[SingleCommand];
-  }
-  const nameArr = mustArray(name);
+function resolveFlattenCommands(commands) {
   const commandsMap = /* @__PURE__ */ new Map();
   for (const command of Object.values(commands)) {
     if (command.alias) {
@@ -62,11 +58,19 @@ function resolveCommand(commands, name) {
         if (alias in commands) {
           throw new CommandNameConflictError(commands[alias].name, command.name);
         }
-        commandsMap.set(alias.split(" "), command);
+        commandsMap.set(alias.split(" "), { ...command, __isAlias: true });
       }
     }
     commandsMap.set(command.name.split(" "), command);
   }
+  return commandsMap;
+}
+function resolveCommand(commands, name) {
+  if (name === SingleCommand) {
+    return commands[SingleCommand];
+  }
+  const nameArr = mustArray(name);
+  const commandsMap = resolveFlattenCommands(commands);
   const possibleCommands = [];
   commandsMap.forEach((v, k) => {
     if (arrayStartsWith(nameArr, k)) {
@@ -332,8 +336,8 @@ const _Clerc = class {
       __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
     const inspectors = [...__privateGet(this, _inspectors), emitHandler];
-    const inspector = compose(inspectors);
-    inspector(getContext);
+    const callInspector = compose(inspectors);
+    callInspector(getContext);
     return this;
   }
 };
@@ -359,4 +363,4 @@ const defineInspector = (_cli, inspector) => inspector;
 const defineCommand = (c) => c;
 const defineCommandWithHandler = (c) => c;
 
-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 };
+export { Clerc, CommandExistsError, CommandNameConflictError, CommonCommandExistsError, MultipleCommandsMatchedError, NoSuchCommandError, ParentCommandExistsError, SingleCommand, SingleCommandAliasError, SingleCommandError, SubcommandExistsError, compose, defineCommand, defineCommandWithHandler, defineHandler, defineInspector, definePlugin, mapParametersToArguments, parseParameters, resolveArgv, resolveCommand, resolveFlattenCommands, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "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.7.0",
+    "@clerc/utils": "npm:@clerc/toolkit@0.8.1",
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "type-flag": "^3.0.0"