breadc 0.4.4 → 0.5.0

package/README.md

@@ -6,7 +6,7 @@ Yet another Command Line Application Framework powered by [minimist](https://www
 
 ## Features
 
-+ ⚡️ **Light-weight**: Only 61 kB.
++ ⚡️ **Light-weight**: Only 40 kB (Unpacked).
 + 📖 **East to Learn**: Breadc is basically compatible with [cac](https://github.com/cacjs/cac) and there are only 4 APIs for building a CLI application: `command`, `option`, `action`, `run`.
 + 💻 **TypeScript Infer**: IDE will automatically infer the type of your command action function.
 

package/dist/index.cjs

@@ -1,14 +1,21 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const kolorist = require('kolorist');
 const minimist = require('minimist');
+const kolorist = require('kolorist');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
-const kolorist__default = /*#__PURE__*/_interopDefaultLegacy(kolorist);
 const minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+const kolorist__default = /*#__PURE__*/_interopDefaultLegacy(kolorist);
+
+function twoColumn(texts, split = "  ") {
+  const left = padRight(texts.map((t) => t[0]));
+  return left.map((l, idx) => l + split + texts[idx][1]);
+}
+function padRight(texts, fill = " ") {
+  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
+  return texts.map((t) => t + fill.repeat(length - t.length));
+}
 
 function createDefaultLogger(name, logger) {
   const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
@@ -59,20 +66,31 @@ const _Option = class {
   }
 };
 let Option = _Option;
-Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
+Option.OptionRE = /^(-[a-zA-Z0-9], )?--([a-zA-Z0-9\-]+)( \[[a-zA-Z0-9]+\]| <[a-zA-Z0-9]+>)?$/;
 
 const _Command = class {
   constructor(format, config) {
     this.options = [];
-    this.format = config.condition ? [format] : format.split(" ").map((t) => t.trim()).filter(Boolean);
-    this.default = this.format.length === 0 || this.format[0][0] === "[" || this.format[0][0] === "<";
+    this.format = format;
+    const pieces = format.split(" ").map((t) => t.trim()).filter(Boolean);
+    const prefix = pieces.filter((p) => !isArg(p));
+    this.default = prefix.length === 0;
+    this.prefix = this.default ? [] : [prefix];
+    this.arguments = pieces.filter(isArg);
     this.description = config.description ?? "";
-    this.conditionFn = config.condition;
     this.logger = config.logger;
-    if (this.format.length > _Command.MaxDep) {
+    if (pieces.length > _Command.MaxDep) {
       this.logger.warn(`Command format string "${format}" is too long`);
     }
   }
+  get isInternal() {
+    return this instanceof InternalCommand;
+  }
+  alias(command) {
+    const pieces = command.split(" ").map((t) => t.trim()).filter(Boolean);
+    this.prefix.push(pieces);
+    return this;
+  }
   option(format, configOrDescription = "", otherConfig = {}) {
     const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
@@ -83,59 +101,56 @@ const _Command = class {
     }
     return this;
   }
-  get hasConditionFn() {
-    return !!this.conditionFn;
-  }
-  shouldRun(args) {
-    if (this.conditionFn) {
-      return this.conditionFn(args);
+  hasPrefix(parsedArgs) {
+    const argv = parsedArgs["_"];
+    if (argv.length === 0) {
+      return this.default;
     } else {
-      if (this.default)
-        return true;
-      const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-      for (let i = 0; i < this.format.length; i++) {
-        if (!isCmd(this.format[i])) {
+      for (const prefix of this.prefix) {
+        if (prefix.length > 0 && prefix[0] === argv[0]) {
           return true;
         }
-        if (i >= args["_"].length || this.format[i] !== args["_"][i]) {
-          return false;
+      }
+      return false;
+    }
+  }
+  shouldRun(parsedArgs) {
+    const args = parsedArgs["_"];
+    for (const prefix of this.prefix) {
+      let match = true;
+      for (let i = 0; match && i < prefix.length; i++) {
+        if (args[i] !== prefix[i]) {
+          match = false;
         }
       }
-      return true;
+      if (match) {
+        args.splice(0, prefix.length);
+        return true;
+      }
     }
+    if (this.default)
+      return true;
+    return false;
   }
   parseArgs(args, globalOptions) {
-    if (this.conditionFn) {
-      const argumentss2 = args["_"];
-      const options2 = args;
-      delete options2["_"];
-      return {
-        command: this,
-        arguments: argumentss2,
-        options: args
-      };
-    }
-    const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
     const argumentss = [];
-    for (let i = 0; i < this.format.length; i++) {
-      if (isCmd(this.format[i]))
-        continue;
+    for (let i = 0; i < this.arguments.length; i++) {
       if (i < args["_"].length) {
-        if (this.format[i].startsWith("[...")) {
+        if (this.arguments[i].startsWith("[...")) {
           argumentss.push(args["_"].slice(i).map(String));
         } else {
           argumentss.push(String(args["_"][i]));
         }
       } else {
-        if (this.format[i].startsWith("<")) {
-          this.logger.warn(`You should provide the argument "${this.format[i]}"`);
-          argumentss.push(void 0);
-        } else if (this.format[i].startsWith("[...")) {
+        if (this.arguments[i].startsWith("<")) {
+          this.logger.warn(`You should provide the argument "${this.arguments[i]}"`);
+          argumentss.push("");
+        } else if (this.arguments[i].startsWith("[...")) {
           argumentss.push([]);
-        } else if (this.format[i].startsWith("[")) {
+        } else if (this.arguments[i].startsWith("[")) {
           argumentss.push(void 0);
         } else {
-          this.logger.warn(`unknown format string ("${this.format[i]}")`);
+          this.logger.warn(`unknown format string ("${this.arguments[i]}")`);
         }
       }
     }
@@ -159,13 +174,14 @@ const _Command = class {
           options[name] = void 0;
         }
       }
-      if (rawOption.construct) {
-        options[name] = rawOption.construct(options[name]);
-      } else if (rawOption.default) {
-        if (!options[name]) {
+      if (rawOption.default !== void 0) {
+        if (options[name] === void 0 || options[name] === false) {
           options[name] = rawOption.default;
         }
       }
+      if (rawOption.construct !== void 0) {
+        options[name] = rawOption.construct(options[name]);
+      }
     }
     for (const key of Object.keys(options)) {
       if (!fullOptions.has(key)) {
@@ -180,88 +196,115 @@ const _Command = class {
   }
   action(fn) {
     this.actionFn = fn;
-    return this;
   }
   async run(...args) {
     if (this.actionFn) {
-      return await this.actionFn(...args, { logger: this.logger });
+      return await this.actionFn(...args, { logger: this.logger, color: kolorist__default });
     } else {
-      this.logger.warn(`You may miss action function in "${this.format}"`);
+      this.logger.warn(`You may miss action function in ${this.format ? `"${this.format}"` : "<default command>"}`);
     }
   }
 };
 let Command = _Command;
 Command.MaxDep = 5;
-function createHelpCommand(breadc) {
-  let helpCommand = void 0;
-  return new Command("-h, --help", {
-    condition(args) {
-      const isEmpty = !args["--"]?.length;
-      if ((args.help || args.h) && isEmpty) {
-        if (args["_"].length > 0) {
-          for (const cmd of breadc.commands) {
-            if (!cmd.hasConditionFn && !cmd.default && cmd.shouldRun(args)) {
-              helpCommand = cmd;
-              return true;
+class InternalCommand extends Command {
+  hasPrefix(_args) {
+    return false;
+  }
+  parseArgs(args, _globalOptions) {
+    const argumentss = args["_"];
+    const options = args;
+    delete options["_"];
+    delete options["help"];
+    delete options["version"];
+    return {
+      command: this,
+      arguments: argumentss,
+      options: args
+    };
+  }
+}
+class HelpCommand extends InternalCommand {
+  constructor(commands, help, logger) {
+    super("-h, --help", { description: "Display this message", logger });
+    this.runCommands = [];
+    this.helpCommands = [];
+    this.commands = commands;
+    this.help = help;
+  }
+  shouldRun(args) {
+    const isRestEmpty = !args["--"]?.length;
+    if ((args.help || args.h) && isRestEmpty) {
+      if (args["_"].length > 0) {
+        for (const cmd of this.commands) {
+          if (!cmd.default && !cmd.isInternal) {
+            if (cmd.shouldRun(args)) {
+              this.runCommands.push(cmd);
+            } else if (cmd.hasPrefix(args)) {
+              this.helpCommands.push(cmd);
             }
           }
         }
-        return true;
-      } else {
-        return false;
       }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    for (const line of breadc.help(helpCommand)) {
-      breadc.logger.println(line);
+      return true;
+    } else {
+      return false;
     }
-  });
+  }
+  async run() {
+    const shouldHelp = this.runCommands.length > 0 ? this.runCommands : this.helpCommands;
+    for (const line of this.help(shouldHelp)) {
+      this.logger.println(line);
+    }
+    this.runCommands.splice(0);
+    this.helpCommands.splice(0);
+  }
 }
-function createVersionCommand(breadc) {
-  return new Command("-v, --version", {
-    condition(args) {
-      const isEmpty = !args["_"].length && !args["--"]?.length;
-      if (args.version && isEmpty) {
-        return true;
-      } else if (args.v && isEmpty) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    breadc.logger.println(breadc.version());
-  });
+class VersionCommand extends InternalCommand {
+  constructor(version, logger) {
+    super("-v, --version", { description: "Display version number", logger });
+    this.version = version;
+  }
+  shouldRun(args) {
+    const isEmpty = !args["_"].length && !args["--"]?.length;
+    if (args.version && isEmpty) {
+      return true;
+    } else if (args.v && isEmpty) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async run() {
+    this.logger.println(this.version);
+  }
+}
+function isArg(arg) {
+  return arg[0] === "[" && arg[arg.length - 1] === "]" || arg[0] === "<" && arg[arg.length - 1] === ">";
 }
 
 class Breadc {
   constructor(name, option) {
     this.options = [];
     this.commands = [];
+    this.callbacks = {
+      pre: [],
+      post: []
+    };
     this.name = name;
     this._version = option.version ?? "unknown";
     this.description = option.description;
     this.logger = createDefaultLogger(name, option.logger);
-    const breadc = {
-      name: this.name,
-      version: () => this.version.call(this),
-      help: (command) => this.help.call(this, command),
-      logger: this.logger,
-      options: this.options,
-      commands: this.commands
-    };
-    this.commands.push(createVersionCommand(breadc), createHelpCommand(breadc));
+    this.commands.push(new VersionCommand(this.version(), this.logger), new HelpCommand(this.commands, this.help.bind(this), this.logger));
   }
   version() {
     return `${this.name}/${this._version}`;
   }
-  help(command) {
+  help(commands = []) {
     const output = [];
     const println = (msg) => output.push(msg);
     println(this.version());
-    if (!command) {
+    if (commands.length === 0) {
       if (this.description) {
         println("");
         if (Array.isArray(this.description)) {
@@ -272,27 +315,26 @@ class Breadc {
           println(this.description);
         }
       }
-    } else {
-      if (command.description) {
-        println("");
-        println(command.description);
-      }
-    }
-    if (!command) {
       if (this.defaultCommand) {
         println(``);
         println(`Usage:`);
-        println(`  $ ${this.name} ${this.defaultCommand.format.join(" ")}`);
+        println(`  $ ${this.name} ${this.defaultCommand.format}`);
+      }
+    } else if (commands.length === 1) {
+      const command = commands[0];
+      if (command.description) {
+        println("");
+        println(command.description);
       }
-    } else {
       println(``);
       println(`Usage:`);
-      println(`  $ ${this.name} ${command.format.join(" ")}`);
+      println(`  $ ${this.name} ${command.format}`);
     }
-    if (!command && this.commands.length > 2) {
+    if (commands.length !== 1) {
+      const cmdList = (commands.length === 0 ? this.commands : commands).filter((c) => !c.isInternal);
       println(``);
       println(`Commands:`);
-      const commandHelps = this.commands.filter((c) => !c.hasConditionFn).map((c) => [`  $ ${this.name} ${c.format.join(" ")}`, c.description]);
+      const commandHelps = cmdList.map((c) => [`  $ ${this.name} ${c.format}`, c.description]);
       for (const line of twoColumn(commandHelps)) {
         println(line);
       }
@@ -300,7 +342,7 @@ class Breadc {
     println(``);
     println(`Options:`);
     const optionHelps = [].concat([
-      ...command ? command.options.map((o) => [`  ${o.format}`, o.description]) : [],
+      ...commands.length > 0 ? commands.flatMap((cmd) => cmd.options.map((o) => [`  ${o.format}`, o.description])) : [],
       ...this.options.map((o) => [`  ${o.format}`, o.description]),
       [`  -h, --help`, `Display this message`],
       [`  -v, --version`, `Display version number`]
@@ -338,15 +380,28 @@ class Breadc {
       ...this.options,
       ...this.commands.flatMap((c) => c.options)
     ];
+    {
+      const names = /* @__PURE__ */ new Map();
+      for (const option of allowOptions) {
+        if (names.has(option.name)) {
+          const otherOption = names.get(option.name);
+          if (otherOption.type !== option.type) {
+            this.logger.warn(`Option "${option.name}" encounters conflict`);
+          }
+        } else {
+          names.set(option.name, option);
+        }
+      }
+    }
     const alias = allowOptions.reduce((map, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
-    }, {});
+    }, { h: "help", v: "version" });
     const argv = minimist__default(args, {
       string: allowOptions.filter((o) => o.type === "string").map((o) => o.name),
-      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name),
+      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name).concat(["help", "version"]),
       alias,
       unknown: (t) => {
         if (t[0] !== "-")
@@ -370,37 +425,36 @@ class Breadc {
       }
     }
     if (this.defaultCommand) {
+      this.defaultCommand.shouldRun(argv);
       return this.defaultCommand.parseArgs(argv, this.options);
     }
     const argumentss = argv["_"];
     const options = argv;
     delete options["_"];
+    delete options["help"];
+    delete options["version"];
     return {
       command: void 0,
       arguments: argumentss,
       options
     };
   }
+  on(event, fn) {
+    this.callbacks[event].push(fn);
+  }
   async run(args) {
     const parsed = this.parse(args);
     if (parsed.command) {
-      return await parsed.command.run(...parsed.arguments, parsed.options);
+      await Promise.all(this.callbacks.pre.map((fn) => fn(parsed.options)));
+      const returnValue = await parsed.command.run(...parsed.arguments, parsed.options);
+      await Promise.all(this.callbacks.post.map((fn) => fn(parsed.options)));
+      return returnValue;
     }
   }
 }
-function twoColumn(texts, split = "  ") {
-  const left = padRight(texts.map((t) => t[0]));
-  return left.map((l, idx) => l + split + texts[idx][1]);
-}
-function padRight(texts, fill = " ") {
-  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
-  return texts.map((t) => t + fill.repeat(length - t.length));
-}
 
 function breadc(name, option = {}) {
   return new Breadc(name, option);
 }
 
-exports.kolorist = kolorist__default;
-exports.minimist = minimist__default;
-exports["default"] = breadc;
+module.exports = breadc;

package/dist/index.d.ts

@@ -1,10 +1,18 @@
+import kolorist from 'kolorist';
 import { ParsedArgs } from 'minimist';
-export { default as minimist } from 'minimist';
-export { default as kolorist } from 'kolorist';
 
 interface OptionConfig<F extends string, T = never> {
+    /**
+     * Option description
+     */
     description?: string;
-    default?: T;
+    /**
+     * Option string default value
+     */
+    default?: string;
+    /**
+     * Transform option text
+     */
     construct?: (rawText: ExtractOptionType<F>) => T;
 }
 /**
@@ -20,7 +28,7 @@ declare class Option<T extends string = string, F = string> {
     private static OptionRE;
     readonly name: string;
     readonly shortcut?: string;
-    readonly default?: F;
+    readonly default?: string;
     readonly format: string;
     readonly description: string;
     readonly type: 'string' | 'boolean';
@@ -29,29 +37,30 @@ declare class Option<T extends string = string, F = string> {
     constructor(format: T, config?: OptionConfig<T, F>);
 }
 
-declare type ConditionFn = (args: ParsedArgs) => boolean;
 interface CommandConfig {
     description?: string;
 }
 declare class Command<F extends string = string, CommandOption extends object = {}> {
-    private static MaxDep;
-    private readonly conditionFn?;
-    private readonly logger;
-    readonly format: string[];
-    readonly default: boolean;
+    protected static MaxDep: number;
+    protected readonly logger: Logger;
+    readonly format: string;
     readonly description: string;
+    readonly prefix: string[][];
+    readonly arguments: string[];
+    readonly default: boolean;
     readonly options: Option[];
     private actionFn?;
     constructor(format: F, config: CommandConfig & {
-        condition?: ConditionFn;
         logger: Logger;
     });
+    get isInternal(): boolean;
+    alias(command: string): this;
     option<OF extends string, T = undefined>(format: OF, description: string, config?: Omit<OptionConfig<OF, T>, 'description'>): Command<F, CommandOption & ExtractOption<OF, T>>;
     option<OF extends string, T = undefined>(format: OF, config?: OptionConfig<OF, T>): Command<F, CommandOption & ExtractOption<OF, T>>;
-    get hasConditionFn(): boolean;
-    shouldRun(args: ParsedArgs): boolean;
+    hasPrefix(parsedArgs: ParsedArgs): boolean;
+    shouldRun(parsedArgs: ParsedArgs): boolean;
     parseArgs(args: ParsedArgs, globalOptions: Option[]): ParseResult;
-    action(fn: ActionFn<ExtractCommand<F>, CommandOption>): this;
+    action(fn: ActionFn<ExtractCommand<F>, CommandOption>): void;
     run(...args: any[]): Promise<any>;
 }
 
@@ -92,6 +101,7 @@ declare type Letter = Lowercase | Uppercase;
 declare type Push<T extends any[], U, R> = [...T, U, R];
 declare type Context = {
     logger: Logger;
+    color: typeof kolorist;
 };
 declare type ActionFn<T extends any[], Option extends object = {}, R = any> = (...arg: Push<T, Option, Context>) => R | Promise<R>;
 /**
@@ -105,18 +115,20 @@ declare class Breadc<GlobalOption extends object = {}> {
     private readonly name;
     private readonly _version;
     private readonly description?;
+    readonly logger: Logger;
     private readonly options;
     private readonly commands;
     private defaultCommand?;
-    readonly logger: Logger;
     constructor(name: string, option: AppOption);
     version(): string;
-    help(command?: Command): string[];
+    help(commands?: Command[]): string[];
     option<F extends string, T = undefined>(format: F, description: string, config?: Omit<OptionConfig<F, T>, 'description'>): Breadc<GlobalOption & ExtractOption<F, T>>;
     option<F extends string, T = undefined>(format: F, config?: OptionConfig<F, T>): Breadc<GlobalOption & ExtractOption<F, T>>;
     command<F extends string>(format: F, description: string, config?: Omit<CommandConfig, 'description'>): Command<F, GlobalOption>;
     command<F extends string>(format: F, config?: CommandConfig): Command<F, GlobalOption>;
     parse(args: string[]): ParseResult;
+    private readonly callbacks;
+    on(event: 'pre' | 'post', fn: (option: GlobalOption) => void | Promise<void>): void;
     run(args: string[]): Promise<any>;
 }
 

package/dist/index.mjs

@@ -1,7 +1,14 @@
-import { blue, yellow, red, gray } from 'kolorist';
-export { default as kolorist } from 'kolorist';
 import minimist from 'minimist';
-export { default as minimist } from 'minimist';
+import kolorist, { blue, yellow, red, gray } from 'kolorist';
+
+function twoColumn(texts, split = "  ") {
+  const left = padRight(texts.map((t) => t[0]));
+  return left.map((l, idx) => l + split + texts[idx][1]);
+}
+function padRight(texts, fill = " ") {
+  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
+  return texts.map((t) => t + fill.repeat(length - t.length));
+}
 
 function createDefaultLogger(name, logger) {
   const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
@@ -52,20 +59,31 @@ const _Option = class {
   }
 };
 let Option = _Option;
-Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
+Option.OptionRE = /^(-[a-zA-Z0-9], )?--([a-zA-Z0-9\-]+)( \[[a-zA-Z0-9]+\]| <[a-zA-Z0-9]+>)?$/;
 
 const _Command = class {
   constructor(format, config) {
     this.options = [];
-    this.format = config.condition ? [format] : format.split(" ").map((t) => t.trim()).filter(Boolean);
-    this.default = this.format.length === 0 || this.format[0][0] === "[" || this.format[0][0] === "<";
+    this.format = format;
+    const pieces = format.split(" ").map((t) => t.trim()).filter(Boolean);
+    const prefix = pieces.filter((p) => !isArg(p));
+    this.default = prefix.length === 0;
+    this.prefix = this.default ? [] : [prefix];
+    this.arguments = pieces.filter(isArg);
     this.description = config.description ?? "";
-    this.conditionFn = config.condition;
     this.logger = config.logger;
-    if (this.format.length > _Command.MaxDep) {
+    if (pieces.length > _Command.MaxDep) {
       this.logger.warn(`Command format string "${format}" is too long`);
     }
   }
+  get isInternal() {
+    return this instanceof InternalCommand;
+  }
+  alias(command) {
+    const pieces = command.split(" ").map((t) => t.trim()).filter(Boolean);
+    this.prefix.push(pieces);
+    return this;
+  }
   option(format, configOrDescription = "", otherConfig = {}) {
     const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
@@ -76,59 +94,56 @@ const _Command = class {
     }
     return this;
   }
-  get hasConditionFn() {
-    return !!this.conditionFn;
-  }
-  shouldRun(args) {
-    if (this.conditionFn) {
-      return this.conditionFn(args);
+  hasPrefix(parsedArgs) {
+    const argv = parsedArgs["_"];
+    if (argv.length === 0) {
+      return this.default;
     } else {
-      if (this.default)
-        return true;
-      const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-      for (let i = 0; i < this.format.length; i++) {
-        if (!isCmd(this.format[i])) {
+      for (const prefix of this.prefix) {
+        if (prefix.length > 0 && prefix[0] === argv[0]) {
           return true;
         }
-        if (i >= args["_"].length || this.format[i] !== args["_"][i]) {
-          return false;
+      }
+      return false;
+    }
+  }
+  shouldRun(parsedArgs) {
+    const args = parsedArgs["_"];
+    for (const prefix of this.prefix) {
+      let match = true;
+      for (let i = 0; match && i < prefix.length; i++) {
+        if (args[i] !== prefix[i]) {
+          match = false;
         }
       }
-      return true;
+      if (match) {
+        args.splice(0, prefix.length);
+        return true;
+      }
     }
+    if (this.default)
+      return true;
+    return false;
   }
   parseArgs(args, globalOptions) {
-    if (this.conditionFn) {
-      const argumentss2 = args["_"];
-      const options2 = args;
-      delete options2["_"];
-      return {
-        command: this,
-        arguments: argumentss2,
-        options: args
-      };
-    }
-    const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
     const argumentss = [];
-    for (let i = 0; i < this.format.length; i++) {
-      if (isCmd(this.format[i]))
-        continue;
+    for (let i = 0; i < this.arguments.length; i++) {
       if (i < args["_"].length) {
-        if (this.format[i].startsWith("[...")) {
+        if (this.arguments[i].startsWith("[...")) {
           argumentss.push(args["_"].slice(i).map(String));
         } else {
           argumentss.push(String(args["_"][i]));
         }
       } else {
-        if (this.format[i].startsWith("<")) {
-          this.logger.warn(`You should provide the argument "${this.format[i]}"`);
-          argumentss.push(void 0);
-        } else if (this.format[i].startsWith("[...")) {
+        if (this.arguments[i].startsWith("<")) {
+          this.logger.warn(`You should provide the argument "${this.arguments[i]}"`);
+          argumentss.push("");
+        } else if (this.arguments[i].startsWith("[...")) {
           argumentss.push([]);
-        } else if (this.format[i].startsWith("[")) {
+        } else if (this.arguments[i].startsWith("[")) {
           argumentss.push(void 0);
         } else {
-          this.logger.warn(`unknown format string ("${this.format[i]}")`);
+          this.logger.warn(`unknown format string ("${this.arguments[i]}")`);
         }
       }
     }
@@ -152,13 +167,14 @@ const _Command = class {
           options[name] = void 0;
         }
       }
-      if (rawOption.construct) {
-        options[name] = rawOption.construct(options[name]);
-      } else if (rawOption.default) {
-        if (!options[name]) {
+      if (rawOption.default !== void 0) {
+        if (options[name] === void 0 || options[name] === false) {
           options[name] = rawOption.default;
         }
       }
+      if (rawOption.construct !== void 0) {
+        options[name] = rawOption.construct(options[name]);
+      }
     }
     for (const key of Object.keys(options)) {
       if (!fullOptions.has(key)) {
@@ -173,88 +189,115 @@ const _Command = class {
   }
   action(fn) {
     this.actionFn = fn;
-    return this;
   }
   async run(...args) {
     if (this.actionFn) {
-      return await this.actionFn(...args, { logger: this.logger });
+      return await this.actionFn(...args, { logger: this.logger, color: kolorist });
     } else {
-      this.logger.warn(`You may miss action function in "${this.format}"`);
+      this.logger.warn(`You may miss action function in ${this.format ? `"${this.format}"` : "<default command>"}`);
     }
   }
 };
 let Command = _Command;
 Command.MaxDep = 5;
-function createHelpCommand(breadc) {
-  let helpCommand = void 0;
-  return new Command("-h, --help", {
-    condition(args) {
-      const isEmpty = !args["--"]?.length;
-      if ((args.help || args.h) && isEmpty) {
-        if (args["_"].length > 0) {
-          for (const cmd of breadc.commands) {
-            if (!cmd.hasConditionFn && !cmd.default && cmd.shouldRun(args)) {
-              helpCommand = cmd;
-              return true;
+class InternalCommand extends Command {
+  hasPrefix(_args) {
+    return false;
+  }
+  parseArgs(args, _globalOptions) {
+    const argumentss = args["_"];
+    const options = args;
+    delete options["_"];
+    delete options["help"];
+    delete options["version"];
+    return {
+      command: this,
+      arguments: argumentss,
+      options: args
+    };
+  }
+}
+class HelpCommand extends InternalCommand {
+  constructor(commands, help, logger) {
+    super("-h, --help", { description: "Display this message", logger });
+    this.runCommands = [];
+    this.helpCommands = [];
+    this.commands = commands;
+    this.help = help;
+  }
+  shouldRun(args) {
+    const isRestEmpty = !args["--"]?.length;
+    if ((args.help || args.h) && isRestEmpty) {
+      if (args["_"].length > 0) {
+        for (const cmd of this.commands) {
+          if (!cmd.default && !cmd.isInternal) {
+            if (cmd.shouldRun(args)) {
+              this.runCommands.push(cmd);
+            } else if (cmd.hasPrefix(args)) {
+              this.helpCommands.push(cmd);
             }
           }
         }
-        return true;
-      } else {
-        return false;
       }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    for (const line of breadc.help(helpCommand)) {
-      breadc.logger.println(line);
+      return true;
+    } else {
+      return false;
     }
-  });
+  }
+  async run() {
+    const shouldHelp = this.runCommands.length > 0 ? this.runCommands : this.helpCommands;
+    for (const line of this.help(shouldHelp)) {
+      this.logger.println(line);
+    }
+    this.runCommands.splice(0);
+    this.helpCommands.splice(0);
+  }
 }
-function createVersionCommand(breadc) {
-  return new Command("-v, --version", {
-    condition(args) {
-      const isEmpty = !args["_"].length && !args["--"]?.length;
-      if (args.version && isEmpty) {
-        return true;
-      } else if (args.v && isEmpty) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    breadc.logger.println(breadc.version());
-  });
+class VersionCommand extends InternalCommand {
+  constructor(version, logger) {
+    super("-v, --version", { description: "Display version number", logger });
+    this.version = version;
+  }
+  shouldRun(args) {
+    const isEmpty = !args["_"].length && !args["--"]?.length;
+    if (args.version && isEmpty) {
+      return true;
+    } else if (args.v && isEmpty) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async run() {
+    this.logger.println(this.version);
+  }
+}
+function isArg(arg) {
+  return arg[0] === "[" && arg[arg.length - 1] === "]" || arg[0] === "<" && arg[arg.length - 1] === ">";
 }
 
 class Breadc {
   constructor(name, option) {
     this.options = [];
     this.commands = [];
+    this.callbacks = {
+      pre: [],
+      post: []
+    };
     this.name = name;
     this._version = option.version ?? "unknown";
     this.description = option.description;
     this.logger = createDefaultLogger(name, option.logger);
-    const breadc = {
-      name: this.name,
-      version: () => this.version.call(this),
-      help: (command) => this.help.call(this, command),
-      logger: this.logger,
-      options: this.options,
-      commands: this.commands
-    };
-    this.commands.push(createVersionCommand(breadc), createHelpCommand(breadc));
+    this.commands.push(new VersionCommand(this.version(), this.logger), new HelpCommand(this.commands, this.help.bind(this), this.logger));
   }
   version() {
     return `${this.name}/${this._version}`;
   }
-  help(command) {
+  help(commands = []) {
     const output = [];
     const println = (msg) => output.push(msg);
     println(this.version());
-    if (!command) {
+    if (commands.length === 0) {
       if (this.description) {
         println("");
         if (Array.isArray(this.description)) {
@@ -265,27 +308,26 @@ class Breadc {
           println(this.description);
         }
       }
-    } else {
-      if (command.description) {
-        println("");
-        println(command.description);
-      }
-    }
-    if (!command) {
       if (this.defaultCommand) {
         println(``);
         println(`Usage:`);
-        println(`  $ ${this.name} ${this.defaultCommand.format.join(" ")}`);
+        println(`  $ ${this.name} ${this.defaultCommand.format}`);
+      }
+    } else if (commands.length === 1) {
+      const command = commands[0];
+      if (command.description) {
+        println("");
+        println(command.description);
       }
-    } else {
       println(``);
       println(`Usage:`);
-      println(`  $ ${this.name} ${command.format.join(" ")}`);
+      println(`  $ ${this.name} ${command.format}`);
     }
-    if (!command && this.commands.length > 2) {
+    if (commands.length !== 1) {
+      const cmdList = (commands.length === 0 ? this.commands : commands).filter((c) => !c.isInternal);
       println(``);
       println(`Commands:`);
-      const commandHelps = this.commands.filter((c) => !c.hasConditionFn).map((c) => [`  $ ${this.name} ${c.format.join(" ")}`, c.description]);
+      const commandHelps = cmdList.map((c) => [`  $ ${this.name} ${c.format}`, c.description]);
       for (const line of twoColumn(commandHelps)) {
         println(line);
       }
@@ -293,7 +335,7 @@ class Breadc {
     println(``);
     println(`Options:`);
     const optionHelps = [].concat([
-      ...command ? command.options.map((o) => [`  ${o.format}`, o.description]) : [],
+      ...commands.length > 0 ? commands.flatMap((cmd) => cmd.options.map((o) => [`  ${o.format}`, o.description])) : [],
       ...this.options.map((o) => [`  ${o.format}`, o.description]),
       [`  -h, --help`, `Display this message`],
       [`  -v, --version`, `Display version number`]
@@ -331,15 +373,28 @@ class Breadc {
       ...this.options,
       ...this.commands.flatMap((c) => c.options)
     ];
+    {
+      const names = /* @__PURE__ */ new Map();
+      for (const option of allowOptions) {
+        if (names.has(option.name)) {
+          const otherOption = names.get(option.name);
+          if (otherOption.type !== option.type) {
+            this.logger.warn(`Option "${option.name}" encounters conflict`);
+          }
+        } else {
+          names.set(option.name, option);
+        }
+      }
+    }
     const alias = allowOptions.reduce((map, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
-    }, {});
+    }, { h: "help", v: "version" });
     const argv = minimist(args, {
       string: allowOptions.filter((o) => o.type === "string").map((o) => o.name),
-      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name),
+      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name).concat(["help", "version"]),
       alias,
       unknown: (t) => {
         if (t[0] !== "-")
@@ -363,32 +418,33 @@ class Breadc {
       }
     }
     if (this.defaultCommand) {
+      this.defaultCommand.shouldRun(argv);
       return this.defaultCommand.parseArgs(argv, this.options);
     }
     const argumentss = argv["_"];
     const options = argv;
     delete options["_"];
+    delete options["help"];
+    delete options["version"];
     return {
       command: void 0,
       arguments: argumentss,
       options
     };
   }
+  on(event, fn) {
+    this.callbacks[event].push(fn);
+  }
   async run(args) {
     const parsed = this.parse(args);
     if (parsed.command) {
-      return await parsed.command.run(...parsed.arguments, parsed.options);
+      await Promise.all(this.callbacks.pre.map((fn) => fn(parsed.options)));
+      const returnValue = await parsed.command.run(...parsed.arguments, parsed.options);
+      await Promise.all(this.callbacks.post.map((fn) => fn(parsed.options)));
+      return returnValue;
     }
   }
 }
-function twoColumn(texts, split = "  ") {
-  const left = padRight(texts.map((t) => t[0]));
-  return left.map((l, idx) => l + split + texts[idx][1]);
-}
-function padRight(texts, fill = " ") {
-  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
-  return texts.map((t) => t + fill.repeat(length - t.length));
-}
 
 function breadc(name, option = {}) {
   return new Breadc(name, option);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breadc",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Yet another Command Line Application Framework with fully strong TypeScript support",
   "keywords": [
     "cli",
@@ -43,11 +43,11 @@
     "bumpp": "^8.2.1",
     "prettier": "^2.7.1",
     "typescript": "^4.7.4",
-    "unbuild": "^0.7.4",
-    "vite": "^2.9.12",
-    "vitest": "^0.15.2"
+    "unbuild": "^0.7.6",
+    "vite": "^3.0.2",
+    "vitest": "^0.18.1"
   },
-  "packageManager": "pnpm@7.3.0",
+  "packageManager": "pnpm@7.5.2",
   "scripts": {
     "build": "unbuild",
     "format": "prettier --write src/**/*.ts test/*.ts examples/*.ts",