breadc 0.8.8 → 0.9.0

package/dist/index.cjs

@@ -1,94 +1,86 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const color = require('@breadc/color');
 
-function makePluginContainer(plugins = []) {
-  const onPreCommand = {};
-  const onPostCommand = {};
-  for (const plugin of plugins) {
-    if (typeof plugin.onPreCommand === "function") {
-      const key = "*";
-      if (!(key in onPreCommand)) {
-        onPreCommand[key] = [];
-      }
-      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);
-      }
+class BreadcError extends Error {
+}
+class ParseError extends Error {
+}
+
+function camelCase(text) {
+  return text.split("-").map((t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)).join("");
+}
+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));
+}
+
+const OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z0-9\-]+)( <[a-zA-Z0-9\-]+>)?$/;
+function makeOption(format, config = { default: void 0 }) {
+  let name = "";
+  let short = void 0;
+  const match = OptionRE.exec(format);
+  if (match) {
+    name = match[2];
+    if (match[1]) {
+      short = match[1][1];
     }
-    if (typeof plugin.onPostCommand === "function") {
-      const key = "*";
-      if (!(key in onPostCommand)) {
-        onPostCommand[key] = [];
+    if (match[3]) {
+      if (name.startsWith("no-")) {
+        throw new BreadcError(`Can not parse option format (${format})`);
       }
-      onPostCommand[key].push(plugin.onPostCommand);
+      const initial = config.default ?? void 0;
+      return {
+        format,
+        type: "string",
+        name,
+        short,
+        description: config.description ?? "",
+        order: 0,
+        // @ts-ignore
+        initial: config.cast ? config.cast(initial) : initial,
+        cast: config.cast
+      };
     } else {
-      for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
-        if (!(key in onPostCommand)) {
-          onPostCommand[key] = [];
-        }
-        onPostCommand[key].push(fn);
+      if (name.startsWith("no-")) {
+        name = name.slice(3);
+        config.default = true;
       }
+      const initial = config.default === void 0 || config.default === null ? false : config.default;
+      return {
+        format,
+        type: "boolean",
+        name,
+        short,
+        description: config.description ?? "",
+        order: 0,
+        // @ts-ignore
+        initial: config.cast ? config.cast(initial) : initial,
+        cast: config.cast
+      };
     }
+  } else {
+    throw new BreadcError(`Can not parse option format (${format})`);
   }
-  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("_");
+}
+const initContextOptions = (options, context) => {
+  for (const option of options) {
+    context.options.set(option.name, option);
+    if (option.short) {
+      context.options.set(option.short, option);
     }
-    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(result)));
-      }
+    if (option.type === "boolean") {
+      context.options.set("no-" + option.name, option);
     }
-  };
-  return {
-    init(breadc, allCommands, globalOptions) {
-      if (plugins.length === 0)
-        return;
-      for (const p of plugins) {
-        p.onInit?.(breadc, allCommands, globalOptions);
-      }
-    },
-    async preRun(breadc) {
-      if (plugins.length === 0)
-        return;
-      for (const p of plugins) {
-        await p.onPreRun?.(breadc);
-      }
-    },
-    async preCommand(command, result) {
-      if (plugins.length === 0)
-        return;
-      await run(onPreCommand, command, result);
-    },
-    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);
-      }
+    if (option.initial !== void 0) {
+      context.result.options[camelCase(option.name)] = option.initial;
     }
-  };
-}
-function definePlugin(plugin) {
-  return plugin;
-}
+  }
+};
 
 class Token {
   constructor(text) {
@@ -169,23 +161,6 @@ class Lexer {
   }
 }
 
-function camelCase(text) {
-  return text.split("-").map((t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)).join("");
-}
-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));
-}
-
-class BreadcError extends Error {
-}
-class ParseError extends Error {
-}
-
 function makeTreeNode(pnode) {
   const node = {
     children: /* @__PURE__ */ new Map(),
@@ -203,6 +178,7 @@ function makeTreeNode(pnode) {
       }
     },
     finish() {
+      return pnode.command?.callback;
     },
     ...pnode
   };
@@ -214,8 +190,8 @@ function parseOption(cursor, token, context) {
   if (context.options.has(key)) {
     const option = context.options.get(key);
     const name = camelCase(option.name);
-    if (option.action) {
-      return option.action(cursor, token, context);
+    if (option.parse) {
+      return option.parse(cursor, token, context);
     } else if (option.type === "boolean") {
       context.result.options[name] = !key.startsWith("no-") ? true : false;
     } else if (option.type === "string") {
@@ -238,7 +214,15 @@ function parseOption(cursor, token, context) {
       context.result.options[name] = option.cast(context.result.options[name]);
     }
   } else {
-    throw new ParseError(`Unknown option ${token.raw()}`);
+    switch (context.config.allowUnknownOption) {
+      case "rest":
+        context.result["--"].push(token.raw());
+      case "skip":
+        break;
+      case "error":
+      default:
+        throw new ParseError(`Unknown option ${token.raw()}`);
+    }
   }
   return cursor;
 }
@@ -251,7 +235,12 @@ function parse(root, args) {
       arguments: [],
       options: {},
       "--": []
-    }
+    },
+    meta: {},
+    config: {
+      allowUnknownOption: "error"
+    },
+    parseOption
   };
   let cursor = root;
   root.init(context);
@@ -259,7 +248,7 @@ function parse(root, args) {
     if (token.type() === "--") {
       break;
     } else if (token.isOption()) {
-      const res = parseOption(cursor, token, context);
+      const res = context.parseOption(cursor, token, context);
       if (res === false) {
         break;
       } else {
@@ -276,81 +265,24 @@ function parse(root, args) {
       throw new ParseError("unreachable");
     }
   }
-  cursor.finish(context);
+  const callback = cursor.finish(context);
   for (const token of lexer) {
     context.result["--"].push(token.raw());
   }
   return {
-    command: cursor.command,
+    callback,
+    matched: {
+      node: cursor,
+      command: cursor.command,
+      option: cursor.option
+    },
+    meta: context.meta,
     arguments: context.result.arguments,
     options: context.result.options,
     "--": context.result["--"]
   };
 }
 
-const OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z0-9\-]+)( <[a-zA-Z0-9\-]+>)?$/;
-function makeOption(format, config = {}) {
-  let name = "";
-  let short = void 0;
-  const match = OptionRE.exec(format);
-  if (match) {
-    name = match[2];
-    if (match[1]) {
-      short = match[1][1];
-    }
-    if (match[3]) {
-      if (name.startsWith("no-")) {
-        throw new BreadcError(`Can not parse option format (${format})`);
-      }
-      const initial = config.default ?? "";
-      return {
-        format,
-        type: "string",
-        name,
-        short,
-        description: config.description ?? "",
-        order: 0,
-        // @ts-ignore
-        initial: config.cast ? config.cast(initial) : initial,
-        cast: config.cast
-      };
-    } else {
-      if (name.startsWith("no-")) {
-        name = name.slice(3);
-        config.default = true;
-      }
-      const initial = config.default === void 0 || config.default === null ? false : config.default;
-      return {
-        format,
-        type: "boolean",
-        name,
-        short,
-        description: config.description ?? "",
-        order: 0,
-        // @ts-ignore
-        initial: config.cast ? config.cast(initial) : initial,
-        cast: config.cast
-      };
-    }
-  } else {
-    throw new BreadcError(`Can not parse option format (${format})`);
-  }
-}
-const initContextOptions = (options, context) => {
-  for (const option of options) {
-    context.options.set(option.name, option);
-    if (option.short) {
-      context.options.set(option.short, option);
-    }
-    if (option.type === "boolean") {
-      context.options.set("no-" + option.name, option);
-    }
-    if (option.initial !== void 0) {
-      context.result.options[camelCase(option.name)] = option.initial;
-    }
-  }
-};
-
 function makeCommand(format, config, root, container) {
   const args = [];
   const options = [];
@@ -401,6 +333,7 @@ function makeCommand(format, config, root, container) {
     return makeTreeNode({
       command,
       init(context) {
+        context.config.allowUnknownOption = config.allowUnknownOption ?? "error";
         initContextOptions(options, context);
       },
       finish(context) {
@@ -424,6 +357,7 @@ function makeCommand(format, config, root, container) {
           }
         }
         context.result["--"] = rest.splice(args2.length);
+        return command.callback;
       }
     });
   }
@@ -520,28 +454,110 @@ function* parseCommandFormat(format) {
   }
   return void 0;
 }
-function makeVersionCommand(name, config) {
-  const command = {
-    async callback() {
-      const text = `${name}/${config.version ? config.version : "unknown"}`;
-      console.log(text);
-      return text;
+
+function makePluginContainer(plugins = []) {
+  const onPreCommand = {};
+  const onPostCommand = {};
+  for (const plugin of plugins) {
+    if (typeof plugin.onPreCommand === "function") {
+      const key = "*";
+      if (!(key in onPreCommand)) {
+        onPreCommand[key] = [];
+      }
+      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);
+      }
+    }
+    if (typeof plugin.onPostCommand === "function") {
+      const key = "*";
+      if (!(key in onPostCommand)) {
+        onPostCommand[key] = [];
+      }
+      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, 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(result)));
+      }
+    }
+  };
+  return {
+    init(breadc, allCommands, globalOptions) {
+      if (plugins.length === 0)
+        return;
+      for (const p of plugins) {
+        p.onInit?.(breadc, allCommands, globalOptions);
+      }
     },
-    format: "-v, --version",
-    description: "Print version",
-    _arguments: [],
-    _options: [],
-    // @ts-ignore
-    option: void 0,
-    // @ts-ignore
-    alias: void 0,
-    // @ts-ignore
-    action: void 0
+    async preRun(breadc) {
+      if (plugins.length === 0)
+        return;
+      for (const p of plugins) {
+        await p.onPreRun?.(breadc);
+      }
+    },
+    async preCommand(command, result) {
+      if (plugins.length === 0)
+        return;
+      await run(onPreCommand, command, result);
+    },
+    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);
+      }
+    }
   };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+
+function makeVersionCommand(name, config) {
+  let description = "Print version";
+  if (typeof config.builtin?.version === "object") {
+    if (config.builtin.version.description) {
+      description = config.builtin.version.description;
+    }
+  }
   const node = makeTreeNode({
-    command,
     next() {
       return false;
+    },
+    finish() {
+      return () => {
+        const text = typeof config.builtin?.version === "object" && config.builtin.version.content ? config.builtin.version.content : `${name}/${config.version ? config.version : "unknown"}`;
+        console.log(text);
+        return text;
+      };
     }
   });
   const option = {
@@ -551,8 +567,8 @@ function makeVersionCommand(name, config) {
     type: "boolean",
     initial: void 0,
     order: 999999999 + 1,
-    description: "Print version",
-    action() {
+    description,
+    parse() {
       return node;
     }
   };
@@ -597,66 +613,66 @@ function makeHelpCommand(name, config, allCommands) {
         }
       }
     }
-    return commands;
+    const alias = /* @__PURE__ */ new Map();
+    for (const cmd of commands) {
+      if (!alias.has(cmd.format)) {
+        alias.set(cmd.format, cmd);
+      }
+    }
+    return [...alias.values()];
+  }
+  let description = "Print help";
+  if (typeof config.builtin?.help === "object") {
+    if (config.builtin.help.description) {
+      description = config.builtin.help.description;
+    }
   }
-  const command = {
-    async callback(parsed) {
-      const context = parsed.options.__context__;
-      const cursor = parsed.options.__cursor__;
-      const usage = allCommands.length === 0 ? `[OPTIONS]` : allCommands.length === 1 ? `[OPTIONS] ${allCommands[0].format}` : allCommands.some((c) => c._default) ? `[OPTIONS] [COMMAND]` : `[OPTIONS] <COMMAND>`;
-      const output = [
-        `${name}/${config.version ? config.version : "unknown"}`,
-        () => {
-          if (config.description) {
-            return ["", config.description];
-          } else {
-            return void 0;
-          }
-        },
-        "",
-        `${color.bold(color.underline("Usage:"))} ${color.bold(name)} ${usage}`,
-        () => {
-          const cmds = expandCommands(cursor);
-          if (cmds.length > 0) {
-            return [
-              "",
-              color.bold(color.underline("Commands:")),
-              cmds.map((cmd) => [
-                `  ${color.bold(name)} ${color.bold(cmd.format)}`,
-                cmd.description
-              ])
-            ];
-          } else {
-            return void 0;
-          }
-        },
-        "",
-        color.bold(color.underline("Options:")),
-        [...context.options.entries()].filter(([key, op]) => key === op.name).sort((lhs, rhs) => lhs[1].order - rhs[1].order).map(([_key, op]) => [
-          "  " + (!op.short ? "    " : "") + color.bold(op.format),
-          op.description
-        ]),
-        ""
-      ];
-      const text = expandMessage(output).join("\n");
-      console.log(text);
-      return text;
-    },
-    format: "-h, --help",
-    description: "Print help",
-    _arguments: [],
-    _options: [],
-    // @ts-ignore
-    option: void 0,
-    // @ts-ignore
-    alias: void 0,
-    // @ts-ignore
-    action: void 0
-  };
   const node = makeTreeNode({
-    command,
     next() {
       return false;
+    },
+    finish(context) {
+      return () => {
+        const cursor = context.meta.__cursor__;
+        const usage = allCommands.length === 0 ? `[OPTIONS]` : allCommands.length === 1 ? `[OPTIONS] ${allCommands[0].format}` : allCommands.some((c) => c._default) ? `[OPTIONS] [COMMAND]` : `[OPTIONS] <COMMAND>`;
+        const output = [
+          `${name}/${config.version ? config.version : "unknown"}`,
+          () => {
+            if (config.description) {
+              return ["", config.description];
+            } else {
+              return void 0;
+            }
+          },
+          "",
+          `${color.bold(color.underline("Usage:"))} ${color.bold(name)} ${usage}`,
+          () => {
+            const cmds = expandCommands(cursor);
+            if (cmds.length > 0) {
+              return [
+                "",
+                color.bold(color.underline("Commands:")),
+                cmds.map((cmd) => [
+                  `  ${color.bold(name)} ${color.bold(cmd.format)}`,
+                  cmd.description
+                ])
+              ];
+            } else {
+              return void 0;
+            }
+          },
+          "",
+          color.bold(color.underline("Options:")),
+          [...context.options.entries()].filter(([key, op]) => key === op.name).sort((lhs, rhs) => lhs[1].order - rhs[1].order).map(([_key, op]) => [
+            "  " + (!op.short ? "    " : "") + color.bold(op.format),
+            op.description
+          ]),
+          ""
+        ];
+        const text = expandMessage(output).join("\n");
+        console.log(text);
+        return text;
+      };
     }
   });
   const option = {
@@ -665,11 +681,10 @@ function makeHelpCommand(name, config, allCommands) {
     short: "h",
     type: "boolean",
     initial: void 0,
-    description: "Print help",
+    description,
     order: 999999999,
-    action(cursor, _token, context) {
-      context.result.options.__cursor__ = cursor;
-      context.result.options.__context__ = context;
+    parse(cursor, _token, context) {
+      context.meta.__cursor__ = cursor;
       return node;
     }
   };
@@ -679,10 +694,13 @@ function makeHelpCommand(name, config, allCommands) {
 function breadc(name, config = {}) {
   let defaultCommand = void 0;
   const allCommands = [];
-  const globalOptions = [
-    makeHelpCommand(name, config, allCommands),
-    makeVersionCommand(name, config)
-  ];
+  const globalOptions = [];
+  if (config.builtin?.help !== false) {
+    globalOptions.push(makeHelpCommand(name, config, allCommands));
+  }
+  if (config.builtin?.version !== false) {
+    globalOptions.push(makeVersionCommand(name, config));
+  }
   const container = makePluginContainer(config.plugins);
   const root = makeTreeNode({
     init(context) {
@@ -690,8 +708,6 @@ function breadc(name, config = {}) {
       if (defaultCommand) {
         initContextOptions(defaultCommand._options, context);
       }
-    },
-    finish() {
     }
   });
   const breadc2 = {
@@ -703,8 +719,8 @@ function breadc(name, config = {}) {
       globalOptions.push(option);
       return breadc2;
     },
-    command(text, _config = {}) {
-      const config2 = typeof _config === "string" ? { description: _config } : _config;
+    command(text, _config = {}, _config2 = {}) {
+      const config2 = typeof _config === "string" ? { description: _config, ..._config2 } : _config;
       const command = makeCommand(text, config2, root, container);
       if (command._default) {
         defaultCommand = command;
@@ -713,19 +729,16 @@ function breadc(name, config = {}) {
       return command;
     },
     parse(args) {
-      const result = parse(root, args);
-      return result;
+      return parse(root, args);
     },
     async run(args) {
       const result = breadc2.parse(args);
-      const command = result.command;
-      if (command) {
-        if (command.callback) {
-          await container.preRun(breadc2);
-          const r = await command.callback(result);
-          await container.postRun(breadc2);
-          return r;
-        }
+      const callback = result.callback;
+      if (callback) {
+        await container.preRun(breadc2);
+        const r = await callback(result);
+        await container.postRun(breadc2);
+        return r;
       }
       return void 0;
     }
@@ -737,6 +750,5 @@ function breadc(name, config = {}) {
 exports.BreadcError = BreadcError;
 exports.ParseError = ParseError;
 exports.breadc = breadc;
-exports.default = breadc;
 exports.definePlugin = definePlugin;
 exports.makeTreeNode = makeTreeNode;