clerc 0.3.4 → 0.5.0

package/dist/index.cjs

@@ -5,20 +5,39 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var liteEmit = require('lite-emit');
 var mri = require('mri');
 var typeFlag = require('type-flag');
-var isPlatform = require('is-platform');
 var utils = require('@clerc/utils');
+var isPlatform = require('is-platform');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var mri__default = /*#__PURE__*/_interopDefaultLegacy(mri);
 
 class SingleCommandError extends Error {
+  constructor() {
+    super("Single command mode enabled.");
+  }
 }
 class CommandExistsError extends Error {
 }
 class CommonCommandExistsError extends Error {
+  constructor() {
+    super("Common command exists.");
+  }
 }
 class NoSuchCommandError extends Error {
+  constructor(name) {
+    super(`No such command: ${name}`);
+  }
+}
+class ParentCommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" cannot exist with its parent`);
+  }
+}
+class SubcommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" cannot exist with its subcommand`);
+  }
 }
 
 const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
@@ -39,114 +58,185 @@ 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) => c.name === name || utils.mustArray(c.alias || []).map(String).includes(name)
+    (c) => utils.arrayStartsWith(nameArr, c.name.split(" ")) || utils.mustArray(c.alias || []).map(String).includes(nameString)
   );
   if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${name}"`);
+    throw new Error(`Multiple commands found with name "${nameString}"`);
   }
   return possibleCommands[0];
 }
+function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
+  const parentArr = parent === "" ? [] : Array.isArray(parent) ? parent : parent.split(" ");
+  return Object.values(commands).filter((c) => {
+    const commandNameArr = c.name.split(" ");
+    return utils.arrayStartsWith(commandNameArr, parentArr) && commandNameArr.length - parentArr.length <= depth;
+  });
+}
+const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
 const resolveArgv = () => isPlatform.isNode() ? process.argv.slice(2) : isPlatform.isDeno() ? Deno.args : [];
 function compose(inspectors) {
-  return (ctx) => {
+  return (getCtx) => {
     return dispatch(0);
     function dispatch(i) {
       const inspector = inspectors[i];
-      return inspector(ctx, dispatch.bind(null, i + 1));
+      return inspector(getCtx(), dispatch.bind(null, i + 1));
     }
   };
 }
 
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _name, _description, _version, _inspectors, _commands, _commandEmitter, _isSingleCommand, isSingleCommand_get, _hasCommands, hasCommands_get;
 const SingleCommand = Symbol("SingleCommand");
-class Clerc {
+const _Clerc = class {
   constructor() {
-    this._name = "";
-    this._description = "";
-    this._version = "";
-    this._inspectors = [];
-    this._commands = {};
-    this.__commandEmitter = new liteEmit.LiteEmit();
+    __privateAdd(this, _isSingleCommand);
+    __privateAdd(this, _hasCommands);
+    __privateAdd(this, _name, "");
+    __privateAdd(this, _description, "");
+    __privateAdd(this, _version, "");
+    __privateAdd(this, _inspectors, []);
+    __privateAdd(this, _commands, {});
+    __privateAdd(this, _commandEmitter, new liteEmit.LiteEmit());
+  }
+  get _name() {
+    return __privateGet(this, _name);
+  }
+  get _description() {
+    return __privateGet(this, _description);
+  }
+  get _version() {
+    return __privateGet(this, _version);
   }
-  get __isSingleCommand() {
-    return this._commands[SingleCommand] !== void 0;
+  get _inspectors() {
+    return __privateGet(this, _inspectors);
   }
-  get __hasCommands() {
-    return Object.keys(this._commands).length > 0;
+  get _commands() {
+    return __privateGet(this, _commands);
   }
   static create() {
-    return new Clerc();
+    return new _Clerc();
   }
   name(name) {
-    this._name = name;
+    __privateSet(this, _name, name);
     return this;
   }
   description(description) {
-    this._description = description;
+    __privateSet(this, _description, description);
     return this;
   }
   version(version) {
-    this._version = version;
+    __privateSet(this, _version, version);
     return this;
   }
   command(name, description, options = {}) {
-    if (this._commands[name]) {
+    if (__privateGet(this, _commands)[name]) {
       if (name === SingleCommand) {
         throw new CommandExistsError("Single command already exists");
       }
       throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
     }
-    if (this.__isSingleCommand) {
-      throw new SingleCommandError("Single command mode enabled");
+    if (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
+      throw new SingleCommandError();
     }
-    if (name === SingleCommand && this.__hasCommands) {
-      throw new CommonCommandExistsError("Common command exists");
+    if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
+      throw new CommonCommandExistsError();
     }
-    const { alias, flags } = options;
-    this._commands[name] = { name, description, alias, flags };
+    if (name !== SingleCommand) {
+      const splitedName = name.split(" ");
+      const existedCommandNames = Object.keys(__privateGet(this, _commands)).filter((name2) => typeof name2 === "string").map((name2) => name2.split(" "));
+      if (existedCommandNames.some((name2) => utils.arrayStartsWith(splitedName, name2))) {
+        throw new ParentCommandExistsError(splitedName.join(" "));
+      }
+      if (existedCommandNames.some((name2) => utils.arrayStartsWith(name2, splitedName))) {
+        throw new SubcommandExistsError(splitedName.join(" "));
+      }
+    }
+    __privateGet(this, _commands)[name] = { name, description, ...options };
     return this;
   }
   on(name, handler) {
-    this.__commandEmitter.on(name, handler);
+    __privateGet(this, _commandEmitter).on(name, handler);
     return this;
   }
   use(plugin) {
     return plugin.setup(this);
   }
   inspector(inspector) {
-    this._inspectors.push(inspector);
+    __privateGet(this, _inspectors).push(inspector);
     return this;
   }
   parse(argv = resolveArgv()) {
     const parsed = mri__default["default"](argv);
-    const name = String(parsed._[0]);
-    const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
-    const isCommandResolved = !!command;
-    const parsedWithType = typeFlag.typeFlag((command == null ? void 0 : command.flags) || {}, argv);
-    const { _: args, flags } = parsedWithType;
-    const parameters = this.__isSingleCommand || !isCommandResolved ? args : args.slice(1);
-    const inspectorContext = {
-      name: command == null ? void 0 : command.name,
-      resolved: isCommandResolved,
-      isSingleCommand: this.__isSingleCommand,
-      raw: parsedWithType,
-      parameters,
-      flags,
-      unknownFlags: parsedWithType.unknownFlags,
-      cli: this
+    const name = parsed._.map(String);
+    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 context = {
+        name: command == null ? void 0 : command.name,
+        resolved: isCommandResolved,
+        isSingleCommand: __privateGet(this, _isSingleCommand, isSingleCommand_get),
+        raw: parsedWithType,
+        parameters,
+        flags,
+        unknownFlags: parsedWithType.unknownFlags,
+        cli: this
+      };
+      return context;
     };
-    const handlerContext = inspectorContext;
     const emitHandler = () => {
+      const command = getCommand();
+      const handlerContext = getContext();
       if (!command) {
-        throw new NoSuchCommandError(`No such command: ${name}`);
+        throw new NoSuchCommandError(stringName);
       }
-      this.__commandEmitter.emit(command.name, handlerContext);
+      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
-    const inspectors = [...this._inspectors, emitHandler];
+    const inspectors = [...__privateGet(this, _inspectors), emitHandler];
     const inspector = compose(inspectors);
-    inspector(inspectorContext);
+    inspector(getContext);
+    return this;
   }
-}
+};
+let Clerc = _Clerc;
+_name = new WeakMap();
+_description = new WeakMap();
+_version = new WeakMap();
+_inspectors = new WeakMap();
+_commands = new WeakMap();
+_commandEmitter = new WeakMap();
+_isSingleCommand = new WeakSet();
+isSingleCommand_get = function() {
+  return __privateGet(this, _commands)[SingleCommand] !== void 0;
+};
+_hasCommands = new WeakSet();
+hasCommands_get = function() {
+  return Object.keys(__privateGet(this, _commands)).length > 0;
+};
 
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
@@ -156,8 +246,10 @@ exports.Clerc = Clerc;
 exports.CommandExistsError = CommandExistsError;
 exports.CommonCommandExistsError = CommonCommandExistsError;
 exports.NoSuchCommandError = NoSuchCommandError;
+exports.ParentCommandExistsError = ParentCommandExistsError;
 exports.SingleCommand = SingleCommand;
 exports.SingleCommandError = SingleCommandError;
+exports.SubcommandExistsError = SubcommandExistsError;
 exports.compose = compose;
 exports.defineHandler = defineHandler;
 exports.defineInspector = defineInspector;
@@ -166,3 +258,5 @@ exports.resolveArgv = resolveArgv;
 exports.resolveCommand = resolveCommand;
 exports.resolveFlagAlias = resolveFlagAlias;
 exports.resolveFlagDefault = resolveFlagDefault;
+exports.resolveRootCommands = resolveRootCommands;
+exports.resolveSubcommandsByParent = resolveSubcommandsByParent;

package/dist/index.d.ts

@@ -1,10 +1,11 @@
+import * as _clerc_utils from '@clerc/utils';
 import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
 
 declare const DOUBLE_DASH = "--";
-declare type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
-declare type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
-declare type FlagType<ReturnType = any> = TypeFunction<ReturnType> | TypeFunctionArray<ReturnType>;
-declare type FlagSchemaBase<TF> = {
+type TypeFunction<ReturnType = any> = (value: any) => ReturnType;
+type TypeFunctionArray<ReturnType> = readonly [TypeFunction<ReturnType>];
+type FlagType<ReturnType = any> = TypeFunction<ReturnType> | TypeFunctionArray<ReturnType>;
+type FlagSchemaBase<TF> = {
     /**
       Type of the flag as a function that parses the argv string and returns the parsed value.
   
@@ -36,7 +37,7 @@ declare type FlagSchemaBase<TF> = {
       */
     alias?: string;
 } & Record<PropertyKey, unknown>;
-declare type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
+type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
     /**
       Default value of the flag. Also accepts a function that returns the default value.
       [Default: undefined]
@@ -53,10 +54,10 @@ declare type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
       */
     default: DefaultType | (() => DefaultType);
 };
-declare type FlagSchema<TF = FlagType> = (FlagSchemaBase<TF> | FlagSchemaDefault<TF>);
-declare type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
-declare type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
-declare type InferFlagType<Flag extends FlagTypeOrSchema> = (Flag extends (TypeFunctionArray<infer T> | FlagSchema<TypeFunctionArray<infer T>>) ? (Flag extends FlagSchemaDefault<TypeFunctionArray<T>, infer D> ? T[] | D : T[]) : (Flag extends TypeFunction<infer T> | FlagSchema<TypeFunction<infer T>> ? (Flag extends FlagSchemaDefault<TypeFunction<T>, infer D> ? T | D : T | undefined) : never));
+type FlagSchema<TF = FlagType> = (FlagSchemaBase<TF> | FlagSchemaDefault<TF>);
+type FlagTypeOrSchema<ExtraOptions = Record<string, unknown>> = FlagType | (FlagSchema & ExtraOptions);
+type Flags<ExtraOptions = Record<string, unknown>> = Record<string, FlagTypeOrSchema<ExtraOptions>>;
+type InferFlagType<Flag extends FlagTypeOrSchema> = (Flag extends (TypeFunctionArray<infer T> | FlagSchema<TypeFunctionArray<infer T>>) ? (Flag extends FlagSchemaDefault<TypeFunctionArray<T>, infer D> ? T[] | D : T[]) : (Flag extends TypeFunction<infer T> | FlagSchema<TypeFunction<infer T>> ? (Flag extends FlagSchemaDefault<TypeFunction<T>, infer D> ? T | D : T | undefined) : never));
 interface ParsedFlags<Schemas = Record<string, unknown>> {
     flags: Schemas;
     unknownFlags: Record<string, (string | boolean)[]>;
@@ -64,33 +65,35 @@ interface ParsedFlags<Schemas = Record<string, unknown>> {
         [DOUBLE_DASH]: string[];
     };
 }
-declare type TypeFlag<Schemas extends Flags> = ParsedFlags<{
+type TypeFlag<Schemas extends Flags> = ParsedFlags<{
     [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
 }>;
 
-declare type FlagOptions = FlagSchema & {
+type FlagOptions = FlagSchema & {
     description: string;
     required?: boolean;
 };
-declare type Flag = FlagOptions & {
+type Flag = FlagOptions & {
     name: string;
 };
 interface CommandOptions<A extends MaybeArray<string> = MaybeArray<string>, F extends Dict<FlagOptions> = Dict<FlagOptions>> {
     alias?: A;
     flags?: F;
+    examples?: [string, string][];
+    notes?: string[];
 }
-declare 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, Options extends CommandOptions = CommandOptions> = Options & {
     name: N;
     description: D;
 };
-declare type CommandRecord = Dict<Command> & {
+type CommandRecord = Dict<Command> & {
     [SingleCommand]?: Command;
 };
-declare type MakeEventMap<T extends CommandRecord> = {
+type MakeEventMap<T extends CommandRecord> = {
     [K in keyof T]: [InspectorContext];
 };
-declare type PossibleInputKind = string | number | boolean | Dict<any>;
-declare type NonNullableFlag<T extends Dict<FlagOptions> | undefined> = T extends undefined ? {} : NonNullable<T>;
+type PossibleInputKind = string | number | boolean | Dict<any>;
+type NonNullableFlag<T extends Dict<FlagOptions> | undefined> = T extends undefined ? {} : NonNullable<T>;
 interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyof C = keyof C> {
     name?: N;
     resolved: boolean;
@@ -101,28 +104,26 @@ interface HandlerContext<C extends CommandRecord = CommandRecord, N extends keyo
     flags: TypeFlag<NonNullableFlag<C[N]["flags"]>>["flags"];
     cli: Clerc<C>;
 }
-declare type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, K>) => void;
-declare type FallbackType<T, U> = {} extends T ? U : T;
-declare type InspectorContext<C extends CommandRecord = CommandRecord> = HandlerContext<C> & {
+type Handler<C extends CommandRecord = CommandRecord, K extends keyof C = keyof C> = (ctx: HandlerContext<C, 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>>;
 };
-declare type Inspector<C extends CommandRecord = CommandRecord> = (ctx: InspectorContext<C>, next: () => void) => void;
+type Inspector<C extends CommandRecord = CommandRecord> = (ctx: InspectorContext<C>, next: () => void) => void;
 interface Plugin<T extends Clerc = Clerc, U extends Clerc = Clerc> {
     setup: (cli: T) => U;
 }
 
 declare const SingleCommand: unique symbol;
-declare type SingleCommandType = typeof SingleCommand;
+type SingleCommandType = typeof SingleCommand;
 declare class Clerc<C extends CommandRecord = {}> {
-    _name: string;
-    _description: string;
-    _version: string;
-    _inspectors: Inspector[];
-    _commands: C;
-    private __commandEmitter;
+    #private;
     private constructor();
-    private get __isSingleCommand();
-    private get __hasCommands();
+    get _name(): string;
+    get _description(): string;
+    get _version(): string;
+    get _inspectors(): Inspector<CommandRecord>[];
+    get _commands(): C;
     /**
      * Create a new cli
      * @returns
@@ -246,7 +247,7 @@ declare class Clerc<C extends CommandRecord = {}> {
      *   .parse(process.argv.slice(2)) // Optional
      * ```
      */
-    parse(argv?: string[]): void;
+    parse(argv?: string[]): this;
 }
 
 declare const definePlugin: <T extends Clerc<{}>, U extends Clerc<{}>>(p: Plugin<T, U>) => Plugin<T, U>;
@@ -254,18 +255,29 @@ declare const defineHandler: <C extends Clerc<{}>, K extends keyof C["_commands"
 declare const defineInspector: <C extends Clerc<{}>>(_cli: C, inspector: Inspector<C["_commands"]>) => Inspector<C["_commands"]>;
 
 declare class SingleCommandError extends Error {
+    constructor();
 }
 declare class CommandExistsError extends Error {
 }
 declare class CommonCommandExistsError extends Error {
+    constructor();
 }
 declare class NoSuchCommandError extends Error {
+    constructor(name: string);
+}
+declare class ParentCommandExistsError extends Error {
+    constructor(name: string);
+}
+declare class SubcommandExistsError extends Error {
+    constructor(name: string);
 }
 
 declare const resolveFlagAlias: (_command: Command) => Dict<string[]>;
 declare const resolveFlagDefault: (_command: Command) => Dict<any>;
-declare function resolveCommand(commands: CommandRecord, name: string | SingleCommandType): Command | undefined;
+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 const resolveArgv: () => string[];
-declare function compose(inspectors: Inspector[]): (ctx: InspectorContext) => void;
+declare function compose(inspectors: Inspector[]): (getCtx: () => InspectorContext) => void;
 
-export { Clerc, Command, CommandExistsError, CommandOptions, CommandRecord, CommonCommandExistsError, FallbackType, Flag, FlagOptions, Handler, HandlerContext, Inspector, InspectorContext, MakeEventMap, NoSuchCommandError, Plugin, PossibleInputKind, SingleCommand, SingleCommandError, SingleCommandType, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+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, resolveRootCommands, resolveSubcommandsByParent };

package/dist/index.mjs

@@ -1,16 +1,35 @@
 import { LiteEmit } from 'lite-emit';
 import mri from 'mri';
 import { typeFlag } from 'type-flag';
+import { mustArray, kebabCase, arrayStartsWith } from '@clerc/utils';
 import { isNode, isDeno } from 'is-platform';
-import { mustArray, kebabCase } from '@clerc/utils';
 
 class SingleCommandError extends Error {
+  constructor() {
+    super("Single command mode enabled.");
+  }
 }
 class CommandExistsError extends Error {
 }
 class CommonCommandExistsError extends Error {
+  constructor() {
+    super("Common command exists.");
+  }
 }
 class NoSuchCommandError extends Error {
+  constructor(name) {
+    super(`No such command: ${name}`);
+  }
+}
+class ParentCommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" cannot exist with its parent`);
+  }
+}
+class SubcommandExistsError extends Error {
+  constructor(name) {
+    super(`Command "${name}" cannot exist with its subcommand`);
+  }
 }
 
 const resolveFlagAlias = (_command) => Object.entries((_command == null ? void 0 : _command.flags) || {}).reduce((acc, [name, command]) => {
@@ -31,117 +50,188 @@ 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) => c.name === name || mustArray(c.alias || []).map(String).includes(name)
+    (c) => arrayStartsWith(nameArr, c.name.split(" ")) || mustArray(c.alias || []).map(String).includes(nameString)
   );
   if (possibleCommands.length > 1) {
-    throw new Error(`Multiple commands found with name "${name}"`);
+    throw new Error(`Multiple commands found with name "${nameString}"`);
   }
   return possibleCommands[0];
 }
+function resolveSubcommandsByParent(commands, parent, depth = Infinity) {
+  const parentArr = parent === "" ? [] : Array.isArray(parent) ? parent : parent.split(" ");
+  return Object.values(commands).filter((c) => {
+    const commandNameArr = c.name.split(" ");
+    return arrayStartsWith(commandNameArr, parentArr) && commandNameArr.length - parentArr.length <= depth;
+  });
+}
+const resolveRootCommands = (commands) => resolveSubcommandsByParent(commands, "", 1);
 const resolveArgv = () => isNode() ? process.argv.slice(2) : isDeno() ? Deno.args : [];
 function compose(inspectors) {
-  return (ctx) => {
+  return (getCtx) => {
     return dispatch(0);
     function dispatch(i) {
       const inspector = inspectors[i];
-      return inspector(ctx, dispatch.bind(null, i + 1));
+      return inspector(getCtx(), dispatch.bind(null, i + 1));
     }
   };
 }
 
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _name, _description, _version, _inspectors, _commands, _commandEmitter, _isSingleCommand, isSingleCommand_get, _hasCommands, hasCommands_get;
 const SingleCommand = Symbol("SingleCommand");
-class Clerc {
+const _Clerc = class {
   constructor() {
-    this._name = "";
-    this._description = "";
-    this._version = "";
-    this._inspectors = [];
-    this._commands = {};
-    this.__commandEmitter = new LiteEmit();
+    __privateAdd(this, _isSingleCommand);
+    __privateAdd(this, _hasCommands);
+    __privateAdd(this, _name, "");
+    __privateAdd(this, _description, "");
+    __privateAdd(this, _version, "");
+    __privateAdd(this, _inspectors, []);
+    __privateAdd(this, _commands, {});
+    __privateAdd(this, _commandEmitter, new LiteEmit());
+  }
+  get _name() {
+    return __privateGet(this, _name);
+  }
+  get _description() {
+    return __privateGet(this, _description);
   }
-  get __isSingleCommand() {
-    return this._commands[SingleCommand] !== void 0;
+  get _version() {
+    return __privateGet(this, _version);
   }
-  get __hasCommands() {
-    return Object.keys(this._commands).length > 0;
+  get _inspectors() {
+    return __privateGet(this, _inspectors);
+  }
+  get _commands() {
+    return __privateGet(this, _commands);
   }
   static create() {
-    return new Clerc();
+    return new _Clerc();
   }
   name(name) {
-    this._name = name;
+    __privateSet(this, _name, name);
     return this;
   }
   description(description) {
-    this._description = description;
+    __privateSet(this, _description, description);
     return this;
   }
   version(version) {
-    this._version = version;
+    __privateSet(this, _version, version);
     return this;
   }
   command(name, description, options = {}) {
-    if (this._commands[name]) {
+    if (__privateGet(this, _commands)[name]) {
       if (name === SingleCommand) {
         throw new CommandExistsError("Single command already exists");
       }
       throw new CommandExistsError(`Command "${name === SingleCommand ? "[SingleCommand]" : name}" already exists`);
     }
-    if (this.__isSingleCommand) {
-      throw new SingleCommandError("Single command mode enabled");
+    if (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
+      throw new SingleCommandError();
     }
-    if (name === SingleCommand && this.__hasCommands) {
-      throw new CommonCommandExistsError("Common command exists");
+    if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
+      throw new CommonCommandExistsError();
     }
-    const { alias, flags } = options;
-    this._commands[name] = { name, description, alias, flags };
+    if (name !== SingleCommand) {
+      const splitedName = name.split(" ");
+      const existedCommandNames = Object.keys(__privateGet(this, _commands)).filter((name2) => typeof name2 === "string").map((name2) => name2.split(" "));
+      if (existedCommandNames.some((name2) => arrayStartsWith(splitedName, name2))) {
+        throw new ParentCommandExistsError(splitedName.join(" "));
+      }
+      if (existedCommandNames.some((name2) => arrayStartsWith(name2, splitedName))) {
+        throw new SubcommandExistsError(splitedName.join(" "));
+      }
+    }
+    __privateGet(this, _commands)[name] = { name, description, ...options };
     return this;
   }
   on(name, handler) {
-    this.__commandEmitter.on(name, handler);
+    __privateGet(this, _commandEmitter).on(name, handler);
     return this;
   }
   use(plugin) {
     return plugin.setup(this);
   }
   inspector(inspector) {
-    this._inspectors.push(inspector);
+    __privateGet(this, _inspectors).push(inspector);
     return this;
   }
   parse(argv = resolveArgv()) {
     const parsed = mri(argv);
-    const name = String(parsed._[0]);
-    const command = this.__isSingleCommand ? this._commands[SingleCommand] : resolveCommand(this._commands, name);
-    const isCommandResolved = !!command;
-    const parsedWithType = typeFlag((command == null ? void 0 : command.flags) || {}, argv);
-    const { _: args, flags } = parsedWithType;
-    const parameters = this.__isSingleCommand || !isCommandResolved ? args : args.slice(1);
-    const inspectorContext = {
-      name: command == null ? void 0 : command.name,
-      resolved: isCommandResolved,
-      isSingleCommand: this.__isSingleCommand,
-      raw: parsedWithType,
-      parameters,
-      flags,
-      unknownFlags: parsedWithType.unknownFlags,
-      cli: this
+    const name = parsed._.map(String);
+    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 context = {
+        name: command == null ? void 0 : command.name,
+        resolved: isCommandResolved,
+        isSingleCommand: __privateGet(this, _isSingleCommand, isSingleCommand_get),
+        raw: parsedWithType,
+        parameters,
+        flags,
+        unknownFlags: parsedWithType.unknownFlags,
+        cli: this
+      };
+      return context;
     };
-    const handlerContext = inspectorContext;
     const emitHandler = () => {
+      const command = getCommand();
+      const handlerContext = getContext();
       if (!command) {
-        throw new NoSuchCommandError(`No such command: ${name}`);
+        throw new NoSuchCommandError(stringName);
       }
-      this.__commandEmitter.emit(command.name, handlerContext);
+      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
     };
-    const inspectors = [...this._inspectors, emitHandler];
+    const inspectors = [...__privateGet(this, _inspectors), emitHandler];
     const inspector = compose(inspectors);
-    inspector(inspectorContext);
+    inspector(getContext);
+    return this;
   }
-}
+};
+let Clerc = _Clerc;
+_name = new WeakMap();
+_description = new WeakMap();
+_version = new WeakMap();
+_inspectors = new WeakMap();
+_commands = new WeakMap();
+_commandEmitter = new WeakMap();
+_isSingleCommand = new WeakSet();
+isSingleCommand_get = function() {
+  return __privateGet(this, _commands)[SingleCommand] !== void 0;
+};
+_hasCommands = new WeakSet();
+hasCommands_get = function() {
+  return Object.keys(__privateGet(this, _commands)).length > 0;
+};
 
 const definePlugin = (p) => p;
 const defineHandler = (_cli, _key, handler) => handler;
 const defineInspector = (_cli, inspector) => inspector;
 
-export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, SingleCommand, SingleCommandError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault };
+export { Clerc, CommandExistsError, CommonCommandExistsError, NoSuchCommandError, ParentCommandExistsError, SingleCommand, SingleCommandError, SubcommandExistsError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault, resolveRootCommands, resolveSubcommandsByParent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clerc",
-  "version": "0.3.4",
+  "version": "0.5.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.3.4",
+    "@clerc/utils": "0.5.0",
     "is-platform": "^0.2.0",
     "lite-emit": "^1.4.0",
     "mri": "^1.2.0",