breadc 0.8.1 → 0.8.3

package/README.md

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

package/dist/index.cjs

@@ -8,44 +8,71 @@ function makePluginContainer(plugins = []) {
   const onPreCommand = {};
   const onPostCommand = {};
   for (const plugin of plugins) {
-    for (const [key, fn] of Object.entries(plugin.onPreCommand ?? {})) {
+    if (typeof plugin.onPreCommand === "function") {
+      const key = "*";
       if (!(key in onPreCommand)) {
         onPreCommand[key] = [];
       }
-      onPreCommand[key].push(fn);
+      onPreCommand[key].push(plugin.onPreCommand);
+    } else {
+      for (const [key, fn] of Object.entries(plugin.onPreCommand ?? {})) {
+        if (!(key in onPreCommand)) {
+          onPreCommand[key] = [];
+        }
+        onPreCommand[key].push(fn);
+      }
     }
-    for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
+    if (typeof plugin.onPostCommand === "function") {
+      const key = "*";
       if (!(key in onPostCommand)) {
         onPostCommand[key] = [];
       }
-      onPostCommand[key].push(fn);
+      onPostCommand[key].push(plugin.onPostCommand);
+    } else {
+      for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
+        if (!(key in onPostCommand)) {
+          onPostCommand[key] = [];
+        }
+        onPostCommand[key].push(fn);
+      }
     }
   }
-  const run = async (container, command) => {
+  const run = async (container, command, result) => {
     const prefix = command._arguments.filter((a) => a.type === "const").map((a) => a.name);
+    if (prefix.length === 0) {
+      prefix.push("_");
+    }
     for (let i = 0; i <= prefix.length; i++) {
       const key = i === 0 ? "*" : prefix.slice(0, i).map(
         (t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)
       ).join("");
       const fns = container[key];
       if (fns && fns.length > 0) {
-        await Promise.all(fns.map((fn) => fn()));
+        await Promise.all(fns.map((fn) => fn(result)));
       }
     }
   };
   return {
     async preRun(breadc) {
+      if (plugins.length === 0)
+        return;
       for (const p of plugins) {
         await p.onPreRun?.(breadc);
       }
     },
-    async preCommand(command) {
-      await run(onPreCommand, command);
+    async preCommand(command, result) {
+      if (plugins.length === 0)
+        return;
+      await run(onPreCommand, command, result);
     },
-    async postCommand(command) {
-      await run(onPostCommand, command);
+    async postCommand(command, result) {
+      if (plugins.length === 0)
+        return;
+      await run(onPostCommand, command, result);
     },
     async postRun(breadc) {
+      if (plugins.length === 0)
+        return;
       for (const p of plugins) {
         await p.onPostRun?.(breadc);
       }
@@ -101,6 +128,7 @@ class Token {
       return this._type = "string";
     }
   }
+  /* c8 ignore next 1 */
 }
 class Lexer {
   constructor(rawArgs) {
@@ -113,7 +141,7 @@ class Lexer {
     return value ? new Token(value) : void 0;
   }
   hasNext() {
-    return this.cursor + 1 < this.rawArgs.length;
+    return this.cursor < this.rawArgs.length;
   }
   peek() {
     const value = this.rawArgs[this.cursor];
@@ -126,7 +154,7 @@ class Lexer {
         const value = that.rawArgs[that.cursor];
         that.cursor += 1;
         return {
-          value: value ? new Token(value) : void 0,
+          value: value !== void 0 ? new Token(value) : void 0,
           done: that.cursor > that.rawArgs.length
         };
       }
@@ -313,13 +341,13 @@ const initContextOptions = (options, context) => {
 };
 
 function makeCommand(format, config, root, container) {
-  let cursor = root;
   const args = [];
   const options = [];
   const command = {
     callback: void 0,
     format,
     description: config.description ?? "",
+    _default: false,
     _arguments: args,
     _options: options,
     option(format2, _config, _config2 = {}) {
@@ -328,87 +356,72 @@ function makeCommand(format, config, root, container) {
       options.push(option);
       return command;
     },
+    alias(format2) {
+      const aliasArgs = [];
+      const node2 = makeNode(aliasArgs);
+      function* g() {
+        for (const f of format2.split(" ")) {
+          yield { type: "const", name: f };
+        }
+        for (const a of args.filter((a2) => a2.type !== "const")) {
+          yield a;
+        }
+        return void 0;
+      }
+      insertTreeNode(aliasArgs, node2, g());
+      return command;
+    },
     action(fn) {
-      command.callback = async (...args2) => {
-        await container.preCommand(command);
-        const result = await fn(...args2);
-        await container.postCommand(command);
+      command.callback = async (parsed) => {
+        await container.preCommand(command, parsed);
+        const result = await fn(...parsed.arguments, {
+          ...parsed.options,
+          "--": parsed["--"]
+        });
+        await container.postCommand(command, parsed);
         return result;
       };
     }
   };
-  const node = makeTreeNode({
-    command,
-    init(context) {
-      initContextOptions(options, context);
-    },
-    finish(context) {
-      const rest = context.result["--"];
-      for (let i = 0; i < args.length; i++) {
-        if (args[i].type === "const") {
-          if (rest[i] !== args[i].name) {
-            throw new ParseError(`Sub-command ${args[i].name} mismatch`);
-          }
-        } else if (args[i].type === "require") {
-          if (i >= rest.length) {
-            throw new ParseError(
-              `You must provide require argument ${args[i].name}`
-            );
+  const node = makeNode(args);
+  insertTreeNode(args, node, parseCommandFormat(format));
+  return command;
+  function makeNode(args2) {
+    return makeTreeNode({
+      command,
+      init(context) {
+        initContextOptions(options, context);
+      },
+      finish(context) {
+        const rest = context.result["--"];
+        for (let i = 0; i < args2.length; i++) {
+          if (args2[i].type === "const") {
+            if (rest[i] !== args2[i].name) {
+              throw new ParseError(`Sub-command ${args2[i].name} mismatch`);
+            }
+          } else if (args2[i].type === "require") {
+            if (i >= rest.length) {
+              throw new ParseError(
+                `You must provide require argument ${args2[i].name}`
+              );
+            }
+            context.result.arguments.push(rest[i]);
+          } else if (args2[i].type === "optional") {
+            context.result.arguments.push(rest[i]);
+          } else if (args2[i].type === "rest") {
+            context.result.arguments.push(rest.splice(i));
           }
-          context.result.arguments.push(rest[i]);
-        } else if (args[i].type === "optional") {
-          context.result.arguments.push(rest[i]);
-        } else if (args[i].type === "rest") {
-          context.result.arguments.push(rest.splice(i));
         }
+        context.result["--"] = rest.splice(args2.length);
       }
-      context.result["--"] = rest.splice(args.length);
-    }
-  });
-  {
-    let state = 0;
-    for (let i = 0; i < format.length; i++) {
-      if (format[i] === "<") {
-        if (state !== 0 && state !== 1) {
-          throw new BreadcError(
-            `Required arguments should be placed before optional or rest arguments`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== ">") {
-          i++;
-        }
-        const name = format.slice(start + 1, i);
-        state = 1;
-        args.push({ type: "require", name });
-      } else if (format[i] === "[") {
-        if (state !== 0 && state !== 1) {
-          throw new BreadcError(
-            `There is at most one optional or rest arguments`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== "]") {
-          i++;
-        }
-        const name = format.slice(start + 1, i);
-        state = 2;
-        if (name.startsWith("...")) {
-          args.push({ type: "rest", name });
-        } else {
-          args.push({ type: "optional", name });
-        }
-      } else if (format[i] !== " ") {
-        if (state !== 0) {
-          throw new BreadcError(
-            `Sub-command should be placed at the beginning`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== " ") {
-          i++;
-        }
-        const name = format.slice(start, i);
+    });
+  }
+  function insertTreeNode(args2, node2, parsed) {
+    let cursor = root;
+    for (const arg of parsed) {
+      args2.push(arg);
+      if (arg.type === "const") {
+        const name = arg.name;
         if (cursor.children.has(name)) {
           cursor = cursor.children.get(name);
         } else {
@@ -431,28 +444,74 @@ function makeCommand(format, config, root, container) {
           cursor.children.set(name, internalNode);
           cursor = internalNode;
         }
-        state = 0;
-        args.push({ type: "const", name });
       }
     }
     cursor.command = command;
     if (cursor !== root) {
       for (const [key, value] of cursor.children) {
-        node.children.set(key, value);
+        node2.children.set(key, value);
       }
-      cursor.children = node.children;
-      cursor.next = node.next;
-      cursor.init = node.init;
-      cursor.finish = node.finish;
+      cursor.children = node2.children;
+      cursor.next = node2.next;
+      cursor.init = node2.init;
+      cursor.finish = node2.finish;
     } else {
-      cursor.finish = node.finish;
+      command._default = true;
+      cursor.finish = node2.finish;
     }
   }
-  return command;
+}
+function* parseCommandFormat(format) {
+  let state = 0;
+  for (let i = 0; i < format.length; i++) {
+    if (format[i] === "<") {
+      if (state !== 0 && state !== 1) {
+        throw new BreadcError(
+          `Required arguments should be placed before optional or rest arguments`
+        );
+      }
+      const start = i;
+      while (i < format.length && format[i] !== ">") {
+        i++;
+      }
+      const name = format.slice(start + 1, i);
+      state = 1;
+      yield { type: "require", name };
+    } else if (format[i] === "[") {
+      if (state !== 0 && state !== 1) {
+        throw new BreadcError(
+          `There is at most one optional or rest arguments`
+        );
+      }
+      const start = i;
+      while (i < format.length && format[i] !== "]") {
+        i++;
+      }
+      const name = format.slice(start + 1, i);
+      state = 2;
+      if (name.startsWith("...")) {
+        yield { type: "rest", name };
+      } else {
+        yield { type: "optional", name };
+      }
+    } else if (format[i] !== " ") {
+      if (state !== 0) {
+        throw new BreadcError(`Sub-command should be placed at the beginning`);
+      }
+      const start = i;
+      while (i < format.length && format[i] !== " ") {
+        i++;
+      }
+      const name = format.slice(start, i);
+      state = 0;
+      yield { type: "const", name };
+    }
+  }
+  return void 0;
 }
 function makeVersionCommand(name, config) {
   const command = {
-    callback() {
+    async callback() {
       const text = `${name}/${config.version ? config.version : "unknown"}`;
       console.log(text);
       return text;
@@ -461,11 +520,12 @@ function makeVersionCommand(name, config) {
     description: "Print version",
     _arguments: [],
     _options: [],
-    option() {
-      return command;
-    },
-    action() {
-    }
+    // @ts-ignore
+    option: void 0,
+    // @ts-ignore
+    alias: void 0,
+    // @ts-ignore
+    action: void 0
   };
   const node = makeTreeNode({
     command,
@@ -527,9 +587,9 @@ function makeHelpCommand(name, config) {
     return commands;
   }
   const command = {
-    callback(option2) {
-      const context = option2.__context__;
-      const cursor = option2.__cursor__;
+    async callback(parsed) {
+      const context = parsed.options.__context__;
+      const cursor = parsed.options.__cursor__;
       const output = [
         `${name}/${config.version ? config.version : "unknown"}`,
         () => {
@@ -570,11 +630,12 @@ function makeHelpCommand(name, config) {
     description: "Print help",
     _arguments: [],
     _options: [],
-    option() {
-      return command;
-    },
-    action() {
-    }
+    // @ts-ignore
+    option: void 0,
+    // @ts-ignore
+    alias: void 0,
+    // @ts-ignore
+    action: void 0
   };
   const node = makeTreeNode({
     command,
@@ -627,7 +688,7 @@ function breadc(name, config = {}) {
     command(text, _config = {}) {
       const config2 = typeof _config === "string" ? { description: _config } : _config;
       const command = makeCommand(text, config2, root, container);
-      if (command._arguments.length === 0 || command._arguments[0].type !== "const") {
+      if (command._default) {
         defaultCommand = command;
       }
       return command;
@@ -642,10 +703,7 @@ function breadc(name, config = {}) {
       if (command) {
         if (command.callback) {
           await container.preRun(breadc2);
-          const r = command.callback(...result.arguments, {
-            ...result.options,
-            "--": result["--"]
-          });
+          const r = await command.callback(result);
           await container.postRun(breadc2);
           return r;
         }

package/dist/index.d.ts

@@ -101,13 +101,15 @@ interface Breadc<GlobalOption extends object = {}> {
     run<T = any>(args: string[]): Promise<T>;
 }
 interface Command<F extends string = string, AT extends any[] = ExtractCommand<F>, CommandOption extends object = {}, GlobalOption extends object = {}> {
-    callback?: ActionFn<ExtractCommand<F>, CommandOption & GlobalOption>;
+    callback?: (result: ParseResult) => Promise<any>;
     format: F;
     description: string;
+    _default: boolean;
     _arguments: Argument[];
     _options: Option[];
     option<OF extends string = string, OT extends string | boolean = ExtractOptionType<OF>, OR extends any = ExtractOptionType<OF>>(format: OF, description?: string, option?: OptionOption<OT, OR>): Command<F, AT, CommandOption & ExtractOption<OF, OR>, GlobalOption>;
     option<OF extends string = string, OT extends string | boolean = ExtractOptionType<OF>, OR extends any = ExtractOptionType<OF>>(format: OF, option?: OptionOption<OT, OR>): Command<F, AT, CommandOption & ExtractOption<OF, OR>, GlobalOption>;
+    alias(format: string): Command<F, AT, CommandOption, GlobalOption>;
     action(fn: ActionFn<AT, CommandOption & GlobalOption>): void;
 }
 interface CommandOption {
@@ -133,10 +135,11 @@ interface OptionOption<T extends string | boolean, R extends any = T> {
     default?: T;
     cast?: (value: T) => R;
 }
+type CommandHookFn = (result: ParseResult) => void | Promise<void>;
 interface Plugin {
     onPreRun(breadc: Breadc): void | Promise<void>;
-    onPreCommand: Record<string, () => void | Promise<void>>;
-    onPostCommand: Record<string, () => void | Promise<void>>;
+    onPreCommand: Record<string, CommandHookFn> | CommandHookFn;
+    onPostCommand: Record<string, CommandHookFn> | CommandHookFn;
     onPostRun(breadc: Breadc): void | Promise<void>;
 }
 

package/dist/index.mjs

@@ -4,44 +4,71 @@ function makePluginContainer(plugins = []) {
   const onPreCommand = {};
   const onPostCommand = {};
   for (const plugin of plugins) {
-    for (const [key, fn] of Object.entries(plugin.onPreCommand ?? {})) {
+    if (typeof plugin.onPreCommand === "function") {
+      const key = "*";
       if (!(key in onPreCommand)) {
         onPreCommand[key] = [];
       }
-      onPreCommand[key].push(fn);
+      onPreCommand[key].push(plugin.onPreCommand);
+    } else {
+      for (const [key, fn] of Object.entries(plugin.onPreCommand ?? {})) {
+        if (!(key in onPreCommand)) {
+          onPreCommand[key] = [];
+        }
+        onPreCommand[key].push(fn);
+      }
     }
-    for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
+    if (typeof plugin.onPostCommand === "function") {
+      const key = "*";
       if (!(key in onPostCommand)) {
         onPostCommand[key] = [];
       }
-      onPostCommand[key].push(fn);
+      onPostCommand[key].push(plugin.onPostCommand);
+    } else {
+      for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
+        if (!(key in onPostCommand)) {
+          onPostCommand[key] = [];
+        }
+        onPostCommand[key].push(fn);
+      }
     }
   }
-  const run = async (container, command) => {
+  const run = async (container, command, result) => {
     const prefix = command._arguments.filter((a) => a.type === "const").map((a) => a.name);
+    if (prefix.length === 0) {
+      prefix.push("_");
+    }
     for (let i = 0; i <= prefix.length; i++) {
       const key = i === 0 ? "*" : prefix.slice(0, i).map(
         (t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)
       ).join("");
       const fns = container[key];
       if (fns && fns.length > 0) {
-        await Promise.all(fns.map((fn) => fn()));
+        await Promise.all(fns.map((fn) => fn(result)));
       }
     }
   };
   return {
     async preRun(breadc) {
+      if (plugins.length === 0)
+        return;
       for (const p of plugins) {
         await p.onPreRun?.(breadc);
       }
     },
-    async preCommand(command) {
-      await run(onPreCommand, command);
+    async preCommand(command, result) {
+      if (plugins.length === 0)
+        return;
+      await run(onPreCommand, command, result);
     },
-    async postCommand(command) {
-      await run(onPostCommand, command);
+    async postCommand(command, result) {
+      if (plugins.length === 0)
+        return;
+      await run(onPostCommand, command, result);
     },
     async postRun(breadc) {
+      if (plugins.length === 0)
+        return;
       for (const p of plugins) {
         await p.onPostRun?.(breadc);
       }
@@ -97,6 +124,7 @@ class Token {
       return this._type = "string";
     }
   }
+  /* c8 ignore next 1 */
 }
 class Lexer {
   constructor(rawArgs) {
@@ -109,7 +137,7 @@ class Lexer {
     return value ? new Token(value) : void 0;
   }
   hasNext() {
-    return this.cursor + 1 < this.rawArgs.length;
+    return this.cursor < this.rawArgs.length;
   }
   peek() {
     const value = this.rawArgs[this.cursor];
@@ -122,7 +150,7 @@ class Lexer {
         const value = that.rawArgs[that.cursor];
         that.cursor += 1;
         return {
-          value: value ? new Token(value) : void 0,
+          value: value !== void 0 ? new Token(value) : void 0,
           done: that.cursor > that.rawArgs.length
         };
       }
@@ -309,13 +337,13 @@ const initContextOptions = (options, context) => {
 };
 
 function makeCommand(format, config, root, container) {
-  let cursor = root;
   const args = [];
   const options = [];
   const command = {
     callback: void 0,
     format,
     description: config.description ?? "",
+    _default: false,
     _arguments: args,
     _options: options,
     option(format2, _config, _config2 = {}) {
@@ -324,87 +352,72 @@ function makeCommand(format, config, root, container) {
       options.push(option);
       return command;
     },
+    alias(format2) {
+      const aliasArgs = [];
+      const node2 = makeNode(aliasArgs);
+      function* g() {
+        for (const f of format2.split(" ")) {
+          yield { type: "const", name: f };
+        }
+        for (const a of args.filter((a2) => a2.type !== "const")) {
+          yield a;
+        }
+        return void 0;
+      }
+      insertTreeNode(aliasArgs, node2, g());
+      return command;
+    },
     action(fn) {
-      command.callback = async (...args2) => {
-        await container.preCommand(command);
-        const result = await fn(...args2);
-        await container.postCommand(command);
+      command.callback = async (parsed) => {
+        await container.preCommand(command, parsed);
+        const result = await fn(...parsed.arguments, {
+          ...parsed.options,
+          "--": parsed["--"]
+        });
+        await container.postCommand(command, parsed);
         return result;
       };
     }
   };
-  const node = makeTreeNode({
-    command,
-    init(context) {
-      initContextOptions(options, context);
-    },
-    finish(context) {
-      const rest = context.result["--"];
-      for (let i = 0; i < args.length; i++) {
-        if (args[i].type === "const") {
-          if (rest[i] !== args[i].name) {
-            throw new ParseError(`Sub-command ${args[i].name} mismatch`);
-          }
-        } else if (args[i].type === "require") {
-          if (i >= rest.length) {
-            throw new ParseError(
-              `You must provide require argument ${args[i].name}`
-            );
+  const node = makeNode(args);
+  insertTreeNode(args, node, parseCommandFormat(format));
+  return command;
+  function makeNode(args2) {
+    return makeTreeNode({
+      command,
+      init(context) {
+        initContextOptions(options, context);
+      },
+      finish(context) {
+        const rest = context.result["--"];
+        for (let i = 0; i < args2.length; i++) {
+          if (args2[i].type === "const") {
+            if (rest[i] !== args2[i].name) {
+              throw new ParseError(`Sub-command ${args2[i].name} mismatch`);
+            }
+          } else if (args2[i].type === "require") {
+            if (i >= rest.length) {
+              throw new ParseError(
+                `You must provide require argument ${args2[i].name}`
+              );
+            }
+            context.result.arguments.push(rest[i]);
+          } else if (args2[i].type === "optional") {
+            context.result.arguments.push(rest[i]);
+          } else if (args2[i].type === "rest") {
+            context.result.arguments.push(rest.splice(i));
           }
-          context.result.arguments.push(rest[i]);
-        } else if (args[i].type === "optional") {
-          context.result.arguments.push(rest[i]);
-        } else if (args[i].type === "rest") {
-          context.result.arguments.push(rest.splice(i));
         }
+        context.result["--"] = rest.splice(args2.length);
       }
-      context.result["--"] = rest.splice(args.length);
-    }
-  });
-  {
-    let state = 0;
-    for (let i = 0; i < format.length; i++) {
-      if (format[i] === "<") {
-        if (state !== 0 && state !== 1) {
-          throw new BreadcError(
-            `Required arguments should be placed before optional or rest arguments`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== ">") {
-          i++;
-        }
-        const name = format.slice(start + 1, i);
-        state = 1;
-        args.push({ type: "require", name });
-      } else if (format[i] === "[") {
-        if (state !== 0 && state !== 1) {
-          throw new BreadcError(
-            `There is at most one optional or rest arguments`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== "]") {
-          i++;
-        }
-        const name = format.slice(start + 1, i);
-        state = 2;
-        if (name.startsWith("...")) {
-          args.push({ type: "rest", name });
-        } else {
-          args.push({ type: "optional", name });
-        }
-      } else if (format[i] !== " ") {
-        if (state !== 0) {
-          throw new BreadcError(
-            `Sub-command should be placed at the beginning`
-          );
-        }
-        const start = i;
-        while (i < format.length && format[i] !== " ") {
-          i++;
-        }
-        const name = format.slice(start, i);
+    });
+  }
+  function insertTreeNode(args2, node2, parsed) {
+    let cursor = root;
+    for (const arg of parsed) {
+      args2.push(arg);
+      if (arg.type === "const") {
+        const name = arg.name;
         if (cursor.children.has(name)) {
           cursor = cursor.children.get(name);
         } else {
@@ -427,28 +440,74 @@ function makeCommand(format, config, root, container) {
           cursor.children.set(name, internalNode);
           cursor = internalNode;
         }
-        state = 0;
-        args.push({ type: "const", name });
       }
     }
     cursor.command = command;
     if (cursor !== root) {
       for (const [key, value] of cursor.children) {
-        node.children.set(key, value);
+        node2.children.set(key, value);
       }
-      cursor.children = node.children;
-      cursor.next = node.next;
-      cursor.init = node.init;
-      cursor.finish = node.finish;
+      cursor.children = node2.children;
+      cursor.next = node2.next;
+      cursor.init = node2.init;
+      cursor.finish = node2.finish;
     } else {
-      cursor.finish = node.finish;
+      command._default = true;
+      cursor.finish = node2.finish;
     }
   }
-  return command;
+}
+function* parseCommandFormat(format) {
+  let state = 0;
+  for (let i = 0; i < format.length; i++) {
+    if (format[i] === "<") {
+      if (state !== 0 && state !== 1) {
+        throw new BreadcError(
+          `Required arguments should be placed before optional or rest arguments`
+        );
+      }
+      const start = i;
+      while (i < format.length && format[i] !== ">") {
+        i++;
+      }
+      const name = format.slice(start + 1, i);
+      state = 1;
+      yield { type: "require", name };
+    } else if (format[i] === "[") {
+      if (state !== 0 && state !== 1) {
+        throw new BreadcError(
+          `There is at most one optional or rest arguments`
+        );
+      }
+      const start = i;
+      while (i < format.length && format[i] !== "]") {
+        i++;
+      }
+      const name = format.slice(start + 1, i);
+      state = 2;
+      if (name.startsWith("...")) {
+        yield { type: "rest", name };
+      } else {
+        yield { type: "optional", name };
+      }
+    } else if (format[i] !== " ") {
+      if (state !== 0) {
+        throw new BreadcError(`Sub-command should be placed at the beginning`);
+      }
+      const start = i;
+      while (i < format.length && format[i] !== " ") {
+        i++;
+      }
+      const name = format.slice(start, i);
+      state = 0;
+      yield { type: "const", name };
+    }
+  }
+  return void 0;
 }
 function makeVersionCommand(name, config) {
   const command = {
-    callback() {
+    async callback() {
       const text = `${name}/${config.version ? config.version : "unknown"}`;
       console.log(text);
       return text;
@@ -457,11 +516,12 @@ function makeVersionCommand(name, config) {
     description: "Print version",
     _arguments: [],
     _options: [],
-    option() {
-      return command;
-    },
-    action() {
-    }
+    // @ts-ignore
+    option: void 0,
+    // @ts-ignore
+    alias: void 0,
+    // @ts-ignore
+    action: void 0
   };
   const node = makeTreeNode({
     command,
@@ -523,9 +583,9 @@ function makeHelpCommand(name, config) {
     return commands;
   }
   const command = {
-    callback(option2) {
-      const context = option2.__context__;
-      const cursor = option2.__cursor__;
+    async callback(parsed) {
+      const context = parsed.options.__context__;
+      const cursor = parsed.options.__cursor__;
       const output = [
         `${name}/${config.version ? config.version : "unknown"}`,
         () => {
@@ -566,11 +626,12 @@ function makeHelpCommand(name, config) {
     description: "Print help",
     _arguments: [],
     _options: [],
-    option() {
-      return command;
-    },
-    action() {
-    }
+    // @ts-ignore
+    option: void 0,
+    // @ts-ignore
+    alias: void 0,
+    // @ts-ignore
+    action: void 0
   };
   const node = makeTreeNode({
     command,
@@ -623,7 +684,7 @@ function breadc(name, config = {}) {
     command(text, _config = {}) {
       const config2 = typeof _config === "string" ? { description: _config } : _config;
       const command = makeCommand(text, config2, root, container);
-      if (command._arguments.length === 0 || command._arguments[0].type !== "const") {
+      if (command._default) {
         defaultCommand = command;
       }
       return command;
@@ -638,10 +699,7 @@ function breadc(name, config = {}) {
       if (command) {
         if (command.callback) {
           await container.preRun(breadc2);
-          const r = command.callback(...result.arguments, {
-            ...result.options,
-            "--": result["--"]
-          });
+          const r = await command.callback(result);
           await container.postRun(breadc2);
           return r;
         }

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "breadc",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Yet another Command Line Application Framework with fully strong TypeScript support",
   "keywords": [
     "breadc",
     "cli",
     "framework",
     "command-line",
-    "minimist",
     "typescript"
   ],
   "homepage": "https://github.com/yjl9903/Breadc#readme",
@@ -35,7 +34,7 @@
     "dist"
   ],
   "dependencies": {
-    "@breadc/color": "0.8.1"
+    "@breadc/color": "0.8.3"
   },
   "devDependencies": {
     "@types/node": "^18.11.18",