clerc 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -0,0 +1,267 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var liteEmit = require('lite-emit');
+var typeFlag = require('type-flag');
+var utils = require('@clerc/utils');
+var isPlatform = require('is-platform');
+
+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]) => {
+  if (command.alias) {
+    const item = utils.mustArray(command.alias).map(utils.kebabCase);
+    acc[utils.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) => 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 "${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);
+function resolveParametersBeforeFlag(argv) {
+  const parameters = [];
+  for (const arg of argv) {
+    if (arg.startsWith("-")) {
+      break;
+    }
+    parameters.push(arg);
+  }
+  return parameters;
+}
+const resolveArgv = () => isPlatform.isNode() ? process.argv.slice(2) : isPlatform.isDeno() ? Deno.args : [];
+function compose(inspectors) {
+  return (getCtx) => {
+    return dispatch(0);
+    function dispatch(i) {
+      const inspector = inspectors[i];
+      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");
+const _Clerc = class {
+  constructor() {
+    __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 _inspectors() {
+    return __privateGet(this, _inspectors);
+  }
+  get _commands() {
+    return __privateGet(this, _commands);
+  }
+  static create() {
+    return new _Clerc();
+  }
+  name(name) {
+    __privateSet(this, _name, name);
+    return this;
+  }
+  description(description) {
+    __privateSet(this, _description, description);
+    return this;
+  }
+  version(version) {
+    __privateSet(this, _version, version);
+    return this;
+  }
+  command(name, description, options = {}) {
+    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 (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
+      throw new SingleCommandError();
+    }
+    if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
+      throw new CommonCommandExistsError();
+    }
+    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) {
+    __privateGet(this, _commandEmitter).on(name, handler);
+    return this;
+  }
+  use(plugin) {
+    return plugin.setup(this);
+  }
+  inspector(inspector) {
+    __privateGet(this, _inspectors).push(inspector);
+    return this;
+  }
+  parse(argv = resolveArgv()) {
+    const name = resolveParametersBeforeFlag(argv);
+    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 emitHandler = () => {
+      const command = getCommand();
+      const handlerContext = getContext();
+      if (!command) {
+        throw new NoSuchCommandError(stringName);
+      }
+      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
+    };
+    const inspectors = [...__privateGet(this, _inspectors), emitHandler];
+    const inspector = compose(inspectors);
+    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;
+
+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;
+exports.definePlugin = definePlugin;
+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

@@ -0,0 +1,284 @@
+import * as _clerc_utils from '@clerc/utils';
+import { MaybeArray, Dict, LiteralUnion } from '@clerc/utils';
+
+declare const DOUBLE_DASH = "--";
+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.
+  
+      @example
+      ```
+      type: String
+      ```
+  
+      @example Wrap in an array to accept multiple values.
+      ```
+      type: [Boolean]
+      ```
+  
+      @example Custom function type that uses moment.js to parse string as date.
+      ```
+      type: function CustomDate(value: string) {
+          return moment(value).toDate();
+      }
+      ```
+      */
+    type: TF;
+    /**
+      A single-character alias for the flag.
+  
+      @example
+      ```
+      alias: 's'
+      ```
+      */
+    alias?: string;
+} & Record<PropertyKey, unknown>;
+type FlagSchemaDefault<TF, DefaultType = any> = FlagSchemaBase<TF> & {
+    /**
+      Default value of the flag. Also accepts a function that returns the default value.
+      [Default: undefined]
+  
+      @example
+      ```
+      default: 'hello'
+      ```
+  
+      @example
+      ```
+      default: () => [1, 2, 3]
+      ```
+      */
+    default: DefaultType | (() => DefaultType);
+};
+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)[]>;
+    _: string[] & {
+        [DOUBLE_DASH]: string[];
+    };
+}
+type TypeFlag<Schemas extends Flags> = ParsedFlags<{
+    [flag in keyof Schemas]: InferFlagType<Schemas[flag]>;
+}>;
+
+type FlagOptions = FlagSchema & {
+    description: string;
+    required?: boolean;
+};
+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[];
+}
+type Command<N extends string | SingleCommandType = string, D extends string = string, Options extends CommandOptions = CommandOptions> = Options & {
+    name: N;
+    description: D;
+};
+type CommandRecord = Dict<Command> & {
+    [SingleCommand]?: Command;
+};
+type MakeEventMap<T extends CommandRecord> = {
+    [K in keyof T]: [InspectorContext];
+};
+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;
+    isSingleCommand: boolean;
+    raw: ParsedFlags;
+    parameters: PossibleInputKind[];
+    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 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>>;
+};
+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;
+type SingleCommandType = typeof SingleCommand;
+declare class Clerc<C extends CommandRecord = {}> {
+    #private;
+    private constructor();
+    get _name(): string;
+    get _description(): string;
+    get _version(): string;
+    get _inspectors(): Inspector<CommandRecord>[];
+    get _commands(): C;
+    /**
+     * Create a new cli
+     * @returns
+     * @example
+     * ```ts
+     * const cli = Clerc.create()
+     * ```
+     */
+    static create(): Clerc<{}>;
+    /**
+     * Set the name of the cli
+     * @param name
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .name("test")
+     * ```
+     */
+    name(name: string): this;
+    /**
+     * Set the description of the cli
+     * @param description
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *  .description("test cli")
+     */
+    description(description: string): this;
+    /**
+     * Set the version of the cli
+     * @param version
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *  .version("1.0.0")
+     */
+    version(version: string): this;
+    /**
+     * Register a command
+     * @param name
+     * @param description
+     * @param options
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .command("test", "test command", {
+     *     alias: "t",
+     *     flags: {
+     *       foo: {
+     *         alias: "f",
+     *         description: "foo flag",
+     *       }
+     *     }
+     *   })
+     * ```
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .command("", "single command", {
+     *     flags: {
+     *       foo: {
+     *         alias: "f",
+     *         description: "foo flag",
+     *       }
+     *     }
+     *   })
+     * ```
+     */
+    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>>>;
+    /**
+     * Register a handler
+     * @param name
+     * @param handler
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .command("test", "test command")
+     *   .on("test", (ctx) => {
+     *     console.log(ctx);
+     *   })
+     * ```
+     */
+    on<K extends keyof CM, CM extends this["_commands"] = this["_commands"]>(name: LiteralUnion<K, string>, handler: Handler<CM, K>): this;
+    /**
+     * Use a plugin
+     * @param plugin
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .use(plugin)
+     * ```
+     */
+    use<T extends Clerc, U extends Clerc>(plugin: Plugin<T, U>): U;
+    /**
+     * Register a inspector
+     * @param inspector
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .inspector((ctx, next) => {
+     *     console.log(ctx);
+     *     next();
+     *   })
+     * ```
+     */
+    inspector(inspector: Inspector): this;
+    /**
+     * Parse the command line arguments
+     * @param args
+     * @returns
+     * @example
+     * ```ts
+     * Clerc.create()
+     *   .parse(process.argv.slice(2)) // Optional
+     * ```
+     */
+    parse(argv?: string[]): this;
+}
+
+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 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 | 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 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 };

package/dist/index.mjs

@@ -0,0 +1,245 @@
+import { LiteEmit } from 'lite-emit';
+import { typeFlag } from 'type-flag';
+import { mustArray, kebabCase, arrayStartsWith } from '@clerc/utils';
+import { isNode, isDeno } from 'is-platform';
+
+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]) => {
+  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)
+  );
+  if (possibleCommands.length > 1) {
+    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);
+function resolveParametersBeforeFlag(argv) {
+  const parameters = [];
+  for (const arg of argv) {
+    if (arg.startsWith("-")) {
+      break;
+    }
+    parameters.push(arg);
+  }
+  return parameters;
+}
+const resolveArgv = () => isNode() ? process.argv.slice(2) : isDeno() ? Deno.args : [];
+function compose(inspectors) {
+  return (getCtx) => {
+    return dispatch(0);
+    function dispatch(i) {
+      const inspector = inspectors[i];
+      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");
+const _Clerc = class {
+  constructor() {
+    __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 _version() {
+    return __privateGet(this, _version);
+  }
+  get _inspectors() {
+    return __privateGet(this, _inspectors);
+  }
+  get _commands() {
+    return __privateGet(this, _commands);
+  }
+  static create() {
+    return new _Clerc();
+  }
+  name(name) {
+    __privateSet(this, _name, name);
+    return this;
+  }
+  description(description) {
+    __privateSet(this, _description, description);
+    return this;
+  }
+  version(version) {
+    __privateSet(this, _version, version);
+    return this;
+  }
+  command(name, description, options = {}) {
+    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 (__privateGet(this, _isSingleCommand, isSingleCommand_get)) {
+      throw new SingleCommandError();
+    }
+    if (name === SingleCommand && __privateGet(this, _hasCommands, hasCommands_get)) {
+      throw new CommonCommandExistsError();
+    }
+    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) {
+    __privateGet(this, _commandEmitter).on(name, handler);
+    return this;
+  }
+  use(plugin) {
+    return plugin.setup(this);
+  }
+  inspector(inspector) {
+    __privateGet(this, _inspectors).push(inspector);
+    return this;
+  }
+  parse(argv = resolveArgv()) {
+    const name = resolveParametersBeforeFlag(argv);
+    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 emitHandler = () => {
+      const command = getCommand();
+      const handlerContext = getContext();
+      if (!command) {
+        throw new NoSuchCommandError(stringName);
+      }
+      __privateGet(this, _commandEmitter).emit(command.name, handlerContext);
+    };
+    const inspectors = [...__privateGet(this, _inspectors), emitHandler];
+    const inspector = compose(inspectors);
+    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, ParentCommandExistsError, SingleCommand, SingleCommandError, SubcommandExistsError, compose, defineHandler, defineInspector, definePlugin, resolveArgv, resolveCommand, resolveFlagAlias, resolveFlagDefault, resolveParametersBeforeFlag, resolveRootCommands, resolveSubcommandsByParent };

package/package.json

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