convoker 0.2.0 → 0.3.2

package/dist/command.js

@@ -1,419 +1,531 @@
-import { D as V, b, c as v, g as O } from "./chunks/color-CiruG_zQ.js";
-import { s as q } from "./chunks/index-D7JQKzRX.js";
-import { m as R, i as A, b as W, a as j } from "./chunks/utils-DdmSEjLc.js";
-import { T as H, M as z, a as N, C as J, H as P, U as K } from "./chunks/error-CBR2veuf.js";
-import { P as B, c as G, O as _ } from "./chunks/input-BfYvlWdG.js";
-async function Q() {
-  if (W && process.stdout?.writable) {
-    const { Writable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((e) => e._);
-    return n.toWeb(process.stdout);
-  }
-  return A && Deno.stdout?.writable ? Deno.stdout.writable : j && Bun.stdout ? Bun.stdout : new WritableStream({
-    write(n) {
-      console.log(String(n));
+import { gray, cyan, bold } from "./color";
+import { setTheme as setPromptTheme } from "./prompt";
+import { setTheme as setLogTheme } from "./log";
+import { ConvokerError, HelpAskedError, MissingRequiredArgumentError, MissingRequiredOptionError, TooManyArgumentsError, UnknownOptionError, } from "./error";
+import { convert, Option, Positional, } from "./input";
+/**
+ * A command.
+ */
+export class Command {
+    /**
+     * Creates a new command.
+     * @param names The names (aliases).
+     * @param desc The description.
+     * @param version The version.
+     */
+    constructor(names, desc, version) {
+        /**
+         * The children of this command.
+         */
+        this.$children = new Map();
+        /**
+         * If this command allows unknown options.
+         */
+        this.$allowUnknownOptions = false;
+        /**
+         * If you should be able to surpass the amount of positional arguments defined in the input.
+         */
+        this.$allowSurpassArgLimit = false;
+        /**
+         * The input this command takes.
+         */
+        this.$input = {};
+        /**
+         * The action function of this command.
+         */
+        this.$fn = undefined;
+        /**
+         * The middlewares associated with this command.
+         */
+        this.$middlewares = [];
+        /**
+         * The error handler of this command.
+         */
+        this.$errorFn = undefined;
+        this.$names = Array.isArray(names) ? names : [names];
+        this.$description = desc;
+        this.$version = version;
     }
-  });
-}
-async function X() {
-  if (W && process.stderr?.writable) {
-    const { Writable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((e) => e._);
-    return n.toWeb(process.stderr);
-  }
-  return A && Deno.stderr?.writable ? Deno.stderr.writable : j && Bun.stderr ? Bun.stderr : new WritableStream({
-    write(n) {
-      console.error(String(n));
+    /**
+     * Adds a set of aliases to this command.
+     * @param aliases The aliases to add.
+     * @returns this
+     */
+    alias(...aliases) {
+        this.$names.concat(aliases);
+        this.$parent?.add(this);
+        return this;
     }
-  });
-}
-async function Y() {
-  if (W && process.stdin?.readable) {
-    const { Readable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((e) => e._);
-    return n.toWeb(process.stdin);
-  }
-  return A && Deno.stdin?.readable ? Deno.stdin.readable : j ? Bun.stdin.stream() : new ReadableStream({
-    start(n) {
-      n.close();
+    /**
+     * Adds a description to this command.
+     * @param desc The description.
+     * @returns this
+     */
+    description(desc) {
+        this.$description = desc;
+        return this;
     }
-  });
-}
-let m = V, g;
-function I(n) {
-  m = n;
-}
-async function L(n) {
-  g = R(
-    {
-      format: "text",
-      stdout: await Q(),
-      stderr: await X(),
-      stdin: await Y()
-    },
-    n
-  );
-}
-async function Z() {
-  await L({});
-}
-function S(n, ...e) {
-  const t = (/* @__PURE__ */ new Date()).toISOString(), r = e.map((i) => typeof i == "string" ? i : JSON.stringify(i, null, 2)).join(" ");
-  switch (g.format) {
-    case "json":
-      return JSON.stringify({ timestamp: t, level: n, message: r }) + `
-`;
-    case "xml":
-      return `<log>
-  <timestamp>${t}</timestamp>
-  <level>${n}</level>
-  <message>${r}</message>
-</log>
-`;
-    case "yaml":
-      return `- timestamp: ${t}
-  level: ${n}
-  message: "${r.replace(/"/g, '\\"')}"
-`;
-    case "csv":
-      return `"${t}","${n}","${r.replace(/"/g, '""')}"
-`;
-    case "text":
-    default:
-      return `[${t}] [${n.toUpperCase()}] ${r}
-`;
-  }
-}
-function E(n, e) {
-  switch (n) {
-    case "trace":
-      return m.secondary ? m.secondary(e) : e;
-    case "info":
-      return m.info ? m.info(e) : e;
-    case "warn":
-      return m.warning ? m.warning(e) : e;
-    case "error":
-      return m.error ? m.error(e) : e;
-    case "fatal":
-      return m.error ? m.error(m.styles?.bold?.(e) ?? e) : e;
-    default:
-      return e;
-  }
-}
-async function k(n, e) {
-  const t = n.getWriter();
-  try {
-    await t.write(e);
-  } finally {
-    t.releaseLock();
-  }
-}
-async function x(...n) {
-  const e = S("trace", ...n), t = E("trace", e);
-  await k(g.stdout, t);
-}
-async function tt(...n) {
-  const e = S("info", ...n), t = E("info", e);
-  await k(g.stdout, t);
-}
-async function et(...n) {
-  const e = S("warn", ...n), t = E("warn", e);
-  await k(g.stdout, t);
-}
-async function nt(...n) {
-  const e = S("error", ...n), t = E("error", e);
-  await k(g.stderr, t);
-}
-async function rt(...n) {
-  const e = S("fatal", ...n), t = E("fatal", e);
-  await k(g.stderr, t), A ? Deno.exit(-1) : (W || j) && process.exit(-1);
-}
-const ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  error: nt,
-  fatal: rt,
-  info: tt,
-  setConfig: L,
-  setTheme: I,
-  setup: Z,
-  trace: x,
-  warn: et
-}, Symbol.toStringTag, { value: "Module" }));
-class F {
-  /**
-   * Creates a new command.
-   * @param names The names (aliases).
-   * @param desc The description.
-   * @param version The version.
-   */
-  constructor(e, t, r) {
-    this.$children = /* @__PURE__ */ new Map(), this.$allowUnknownOptions = !1, this.$allowSurpassArgLimit = !1, this.$input = {}, this.$fn = void 0, this.$errorFn = void 0, this.$names = Array.isArray(e) ? e : [e], this.$description = t, this.$version = r;
-  }
-  /**
-   * Adds a set of aliases to this command.
-   * @param aliases The aliases to add.
-   * @returns this
-   */
-  alias(...e) {
-    return this.$names.concat(e), this.$parent?.add(this), this;
-  }
-  /**
-   * Adds a description to this command.
-   * @param desc The description.
-   * @returns this
-   */
-  description(e) {
-    return this.$description = e, this;
-  }
-  /**
-   * Adds a version to this command.
-   * @param version The version.
-   * @returns this
-   */
-  version(e) {
-    return this.$version = e, this;
-  }
-  /**
-   * Sets the input for this command.
-   * @param version The input.
-   * @returns this
-   */
-  input(e) {
-    return this.$input = e, this;
-  }
-  /**
-   * Sets the action function for this command.
-   * @param fn The action.
-   * @returns this
-   */
-  action(e) {
-    return this.$fn = e, this;
-  }
-  /**
-   * Sets the error function for this command.
-   * @param fn The error handler.
-   * @returns this
-   */
-  error(e) {
-    return this.$errorFn = e, this;
-  }
-  /**
-   * Adds an existing command to this.
-   * @param command The command.
-   * @returns this
-   */
-  add(e) {
-    e.$parent = this;
-    const t = { command: e, alias: e.$names[0] };
-    for (let r = 0; r < e.$names.length; r++)
-      r === 0 && this.$children.set(e.$names[r], { command: e }), this.$children.set(e.$names[r], t);
-    return this;
-  }
-  subCommand(e, t, r) {
-    if (typeof t == "function") {
-      const a = new F(e);
-      return t(a), this.add(a), this;
+    /**
+     * Adds a version to this command.
+     * @param version The version.
+     * @returns this
+     */
+    version(version) {
+        this.$version = version;
+        return this;
+    }
+    /**
+     * Sets the input for this command.
+     * @param version The input.
+     * @returns this
+     */
+    input(input) {
+        this.$input = input;
+        return this;
+    }
+    /**
+     * Adds a chain of middlewares.
+     * @param fns The middlewares to use.
+     * @returns this
+     */
+    use(...fns) {
+        this.$middlewares.push(...fns);
+        return this;
     }
-    const i = new F(e, t, r);
-    return this.add(i), i;
-  }
-  /**
-   * Allows unknown options.
-   * @returns this
-   */
-  allowUnknownOptions() {
-    return this.$allowUnknownOptions = !0, this;
-  }
-  /**
-   * Parses a set of command-line arguments.
-   * @param argv The arguments to parse.
-   * @returns A parse result.
-   */
-  async parse(e) {
-    let t = this, r = !1;
-    const i = {}, a = [], d = {}, s = [], c = t.buildInputMap();
-    function u(f, o) {
-      const l = c.get(f);
-      return l ? l.value : (!t.$allowUnknownOptions && !o && s.push(new K(t, f)), null);
+    /**
+     * Sets the action function for this command.
+     * @param fn The action.
+     * @returns this
+     */
+    action(fn) {
+        this.$fn = fn;
+        return this;
     }
-    function h(f, o, l) {
-      o.$kind === "boolean" ? d[f] = "true" : l !== void 0 && (d[f] = l);
+    /**
+     * Sets the error function for this command.
+     * @param fn The error handler.
+     * @returns this
+     */
+    error(fn) {
+        this.$errorFn = fn;
+        return this;
     }
-    let p = !1, C = !1;
-    for (let f = 0; f < e.length; f++) {
-      const o = e[f];
-      if (o.startsWith("--")) {
-        const [l, w] = o.slice(2).split("=");
-        let y = !1;
-        l === "help" ? (C = !0, y = !0) : l === "version" && (p = !0, y = !0);
-        const $ = u(l, y);
-        $ && (w === void 0 ? h(
-          l,
-          $,
-          $.$kind === "boolean" ? void 0 : e[++f]
-        ) : h(l, $, w));
-      } else if (o.startsWith("-")) {
-        const [l, w] = o.slice(1).split("="), y = l.split("");
-        let $ = w;
-        for (const D of y) {
-          let T = !1;
-          D === "h" ? (C = !0, T = !0) : D === "V" && (p = !0, T = !0);
-          const U = u(D, T);
-          U && (U.$kind !== "boolean" && $ === void 0 && ($ = e[++f]), h(D, U, $), $ = void 0);
+    /**
+     * Adds an existing command to this.
+     * @param command The command.
+     * @returns this
+     */
+    add(command) {
+        command.$parent = this;
+        const alias = { command, alias: command.$names[0] };
+        for (let i = 0; i < command.$names.length; i++) {
+            if (i === 0)
+                this.$children.set(command.$names[i], { command });
+            this.$children.set(command.$names[i], alias);
         }
-      } else
-        t.$children.has(o) && !r ? (t = t.$children.get(o).command, t.$theme && (q(t.$theme), I(t.$theme))) : (r = !0, a.push(o));
+        return this;
     }
-    let M = 0;
-    for (const f in t.$input) {
-      const o = t.$input[f];
-      let l;
-      if (o instanceof B) {
-        if (o.$list) {
-          if (l = a.slice(M), M = a.length, !t.$allowSurpassArgLimit && l.length === 0)
-            throw new H(t);
-        } else if (l = a[M++], M > a.length && !t.$allowSurpassArgLimit)
-          throw new H(t);
-      } else
-        for (const w of o.$names)
-          if (d[w] !== void 0) {
-            l = o.$list ? d[w] : d[w].split(o.$separator ?? ",");
-            break;
-          }
-      l !== void 0 ? i[f] = await G(o.$kind, l) : o.$default !== void 0 ? i[f] = o.$default : o.$required && (o instanceof _ ? s.push(new z(t, f, o)) : s.push(new N(t, f, o)));
+    subCommand(names, descOrBuilder, version) {
+        if (typeof descOrBuilder === "function") {
+            const command = new Command(names);
+            descOrBuilder(command);
+            this.add(command);
+            return this;
+        }
+        const command = new Command(names, descOrBuilder, version);
+        this.add(command);
+        return command;
     }
-    return {
-      input: i,
-      command: t,
-      errors: s,
-      isVersion: p,
-      isHelp: C
-    };
-  }
-  buildInputMap(e) {
-    const t = /* @__PURE__ */ new Map();
-    let r = 0;
-    for (const i in this.$input) {
-      const a = this.$input[i];
-      if (a instanceof B)
-        t.set(r++, { value: a, key: i });
-      else
-        for (const d of a.$names)
-          t.set(d, { value: a, key: i });
+    /**
+     * Allows unknown options.
+     * @returns this
+     */
+    allowUnknownOptions() {
+        this.$allowUnknownOptions = true;
+        return this;
     }
-    if (!e)
-      for (const [i, a] of this.$parent?.buildInputMap() ?? [])
-        t.set(i, a);
-    for (const [, { command: i }] of this.$children)
-      for (const [a, d] of i.buildInputMap(!0))
-        t.set(a, d);
-    return t;
-  }
-  /**
-   * Gets the full command path (name including parents).
-   * @returns The full command path.
-   */
-  fullCommandPath() {
-    const e = [];
-    let t = this;
-    for (; t; )
-      e.unshift(t.$names[0]), t = t.$parent;
-    return e.join(" ");
-  }
-  /**
-   * The default error screen.
-   * @param errors The errors.
-   */
-  defaultErrorScreen(e) {
-    let t = !1;
-    const r = [];
-    for (const s of e)
-      s instanceof J ? (s instanceof P || s.print(), t = !0) : r.push(s);
-    if (r.length) throw r[0];
-    if (!t) return;
-    const i = (s, c) => s.padEnd(c, " ");
-    console.log(
-      `${b("usage:")} ${v(this.fullCommandPath())} ${O("[options] [arguments]")}`
-    ), this.$description && console.log(`${this.$description}`), this.$version && console.log(`${b("version")} ${this.$version}`);
-    const a = Object.entries(this.$input).filter(([, s]) => s instanceof _).map(([s, c]) => ({ key: s, entry: c }));
-    if (a.length > 0) {
-      console.log(b("options:"));
-      const s = Math.max(
-        ...a.map(({ entry: c }) => c.$names.join(", ").length)
-      );
-      for (const { entry: c } of a) {
-        const u = c.$names.map((p) => p.length === 1 ? `-${p}` : `--${p}`).join(", "), h = `  ${v(i(u, s + 4))}${O(c.$description ?? "")}`;
-        console.log(h);
-      }
+    /**
+     * Parses a set of command-line arguments.
+     * @param argv The arguments to parse.
+     * @returns A parse result.
+     */
+    async parse(argv) {
+        // eslint-disable-next-line -- alias to this is necessary to go through the tree
+        let command = this;
+        let found = false;
+        const input = {};
+        const args = [];
+        const opts = {};
+        const errors = [];
+        const map = command.buildInputMap();
+        function getOption(key, isSpecial) {
+            const entry = map.get(key);
+            if (!entry) {
+                if (!command.$allowUnknownOptions && !isSpecial)
+                    errors.push(new UnknownOptionError(command, key));
+                return null;
+            }
+            return entry.value;
+        }
+        function setOption(key, option, value) {
+            if (option.$kind === "boolean") {
+                opts[key] = "true";
+            }
+            else if (value !== undefined) {
+                opts[key] = value;
+            }
+        }
+        let isVersion = false;
+        let isHelp = false;
+        for (let i = 0; i < argv.length; i++) {
+            const arg = argv[i];
+            if (arg.startsWith("--")) {
+                // --long[=value] or --long [value]
+                const [key, value] = arg.slice(2).split("=");
+                let isSpecial = false;
+                if (key === "help") {
+                    isHelp = true;
+                    isSpecial = true;
+                }
+                else if (key === "version") {
+                    isVersion = true;
+                    isSpecial = true;
+                }
+                const option = getOption(key, isSpecial);
+                if (option) {
+                    if (value === undefined)
+                        setOption(key, option, option.$kind === "boolean" ? undefined : argv[++i]);
+                    else
+                        setOption(key, option, value);
+                }
+            }
+            else if (arg.startsWith("-")) {
+                // -abc or -k[=value] or -k [value]
+                const [shortKeys, value] = arg.slice(1).split("=");
+                const chars = shortKeys.split("");
+                let usedValue = value;
+                for (const char of chars) {
+                    let isSpecial = false;
+                    if (char === "h") {
+                        isHelp = true;
+                        isSpecial = true;
+                    }
+                    else if (char === "V") {
+                        isVersion = true;
+                        isSpecial = true;
+                    }
+                    const option = getOption(char, isSpecial);
+                    if (!option)
+                        continue;
+                    if (option.$kind !== "boolean" && usedValue === undefined) {
+                        usedValue = argv[++i];
+                    }
+                    setOption(char, option, usedValue);
+                    usedValue = undefined; // only first consumes
+                }
+            }
+            else {
+                // positional
+                if (command.$children.has(arg) && !found) {
+                    command = command.$children.get(arg).command;
+                    if (command.$theme) {
+                        setPromptTheme(command.$theme);
+                        setLogTheme(command.$theme);
+                    }
+                }
+                else {
+                    found = true;
+                    args.push(arg);
+                }
+            }
+        }
+        // Apply user values, defaults, or enforce required
+        let index = 0;
+        for (const key in command.$input) {
+            const entry = command.$input[key];
+            let rawValue;
+            if (entry instanceof Positional) {
+                if (entry.$list) {
+                    rawValue = args.slice(index);
+                    index = args.length;
+                    if (!command.$allowSurpassArgLimit &&
+                        rawValue.length === 0 &&
+                        entry.$required) {
+                        errors.push(new MissingRequiredArgumentError(command, key, entry));
+                    }
+                }
+                else {
+                    rawValue = args[index++];
+                    if (rawValue === undefined && entry.$required) {
+                        errors.push(new MissingRequiredArgumentError(command, key, entry));
+                    }
+                }
+            }
+            else {
+                for (const name of entry.$names) {
+                    if (opts[name] !== undefined) {
+                        rawValue = entry.$list
+                            ? opts[name].split(entry.$separator ?? ",")
+                            : opts[name];
+                        break;
+                    }
+                }
+            }
+            if (rawValue !== undefined) {
+                input[key] = await convert(entry.$kind, rawValue);
+            }
+            else if (entry.$default !== undefined) {
+                input[key] = entry.$default;
+            }
+            else if (entry.$required) {
+                if (entry instanceof Option) {
+                    errors.push(new MissingRequiredOptionError(command, key, entry));
+                }
+                else {
+                    errors.push(new MissingRequiredArgumentError(command, key, entry));
+                }
+            }
+        }
+        // Check for too many arguments
+        const remainingArgs = args.slice(index);
+        if (!command.$allowSurpassArgLimit && remainingArgs.length > 0) {
+            errors.push(new TooManyArgumentsError(command));
+        }
+        return {
+            input: input,
+            command,
+            errors,
+            isVersion,
+            isHelp,
+        };
     }
-    const d = Object.entries(this.$input).filter(([, s]) => s instanceof B).map(([s, c]) => ({
-      key: s,
-      entry: c
-    }));
-    if (d.length > 0) {
-      console.log(b("arguments:"));
-      const s = Math.max(...d.map(({ key: c }) => c.length));
-      for (const { key: c, entry: u } of d) {
-        const h = u.$required ? `<${c}>` : `[${c}]`, p = `  ${v(i(h, s + 4))}${O(u.$description ?? "")}`;
-        console.log(p);
-      }
+    buildInputMap(ignoreParentMap) {
+        const map = new Map();
+        let i = 0;
+        for (const key in this.$input) {
+            const value = this.$input[key];
+            if (value instanceof Positional) {
+                map.set(i++, { value, key });
+            }
+            else {
+                for (const name of value.$names) {
+                    map.set(name, { value, key });
+                }
+            }
+        }
+        if (!ignoreParentMap) {
+            for (const [key, entry] of this.$parent?.buildInputMap() ?? []) {
+                map.set(key, entry);
+            }
+        }
+        for (const [, { command }] of this.$children) {
+            for (const [key, entry] of command.buildInputMap(true)) {
+                map.set(key, entry);
+            }
+        }
+        return map;
+    }
+    /**
+     * Allows surpassing the amount of arguments specified.
+     * @returns this
+     */
+    allowSurpassArgLimit() {
+        this.$allowSurpassArgLimit = true;
+        return this;
+    }
+    /**
+     * Gets the full command path (name including parents).
+     * @returns The full command path.
+     */
+    fullCommandPath() {
+        const names = [];
+        // eslint-disable-next-line -- necessary for traversing up the tree
+        let cmd = this;
+        while (cmd) {
+            names.unshift(cmd.$names[0]);
+            cmd = cmd.$parent;
+        }
+        return names.join(" ");
+    }
+    /**
+     * The default error screen.
+     * @param errors The errors.
+     */
+    defaultErrorScreen(errors) {
+        let printHelpScreen = false;
+        const nonCliErrors = [];
+        for (const error of errors) {
+            if (error instanceof ConvokerError) {
+                if (!(error instanceof HelpAskedError))
+                    error.print();
+                printHelpScreen = true;
+            }
+            else {
+                nonCliErrors.push(error);
+            }
+        }
+        if (nonCliErrors.length)
+            throw nonCliErrors[0];
+        if (!printHelpScreen)
+            return;
+        const pad = (s, len) => s.padEnd(len, " ");
+        console.log(`${bold("usage:")} ${cyan(this.fullCommandPath())} ${gray("[options] [arguments]")}`);
+        if (this.$description) {
+            console.log(`${this.$description}`);
+        }
+        if (this.$version) {
+            console.log(`${bold("version")} ${this.$version}`);
+        }
+        // OPTIONS
+        const opts = Object.entries(this.$input)
+            .filter(([, entry]) => entry instanceof Option)
+            .map(([key, entry]) => ({ key, entry: entry }));
+        if (opts.length > 0) {
+            console.log(bold("options:"));
+            const longest = Math.max(...opts.map(({ entry }) => entry.$names.join(", ").length));
+            for (const { entry } of opts) {
+                const names = entry.$names
+                    .map((n) => (n.length === 1 ? `-${n}` : `--${n}`))
+                    .join(", ");
+                const line = `  ${cyan(pad(names, longest + 4))}${gray(entry.$description ?? "")}`;
+                console.log(line);
+            }
+        }
+        // POSITIONALS
+        const positionals = Object.entries(this.$input)
+            .filter(([, entry]) => entry instanceof Positional)
+            .map(([key, entry]) => ({
+            key,
+            entry: entry,
+        }));
+        if (positionals.length > 0) {
+            console.log(bold("arguments:"));
+            const longest = Math.max(...positionals.map(({ key }) => key.length));
+            for (const { key, entry } of positionals) {
+                const name = entry.$required ? `<${key}>` : `[${key}]`;
+                const line = `  ${cyan(pad(name, longest + 4))}${gray(entry.$description ?? "")}`;
+                console.log(line);
+            }
+        }
+        // SUBCOMMANDS
+        if (this.$children.size > 0) {
+            console.log(bold("sub commands:"));
+            const deduped = Array.from(new Map([...this.$children.values()].map((a) => [
+                a.command.$names[0],
+                a.command,
+            ])).values());
+            const longest = Math.max(...deduped.map((c) => c.$names[0].length));
+            for (const cmd of deduped) {
+                const line = `  ${cyan(pad(cmd.$names[0], longest + 4))}${gray(cmd.$description) ?? ""}`;
+                console.log(line);
+            }
+            console.log();
+            console.log(`run '${cyan(`${this.fullCommandPath()} <command> --help`)}' for more info on a command.`);
+        }
+    }
+    /**
+     * Handles a set of errors.
+     * @param errors The errors to handle.
+     * @param input The parsed input, if possible.
+     * @returns this
+     */
+    async handleErrors(errors, input) {
+        // eslint-disable-next-line -- necessary for traversing up the tree
+        let command = this;
+        while (!command.$errorFn && command.$parent) {
+            command = command.$parent;
+        }
+        if (command.$errorFn) {
+            await command.$errorFn(command, errors, input ?? {});
+        }
+        else {
+            this.defaultErrorScreen(errors);
+        }
+        return this;
     }
-    if (this.$children.size > 0) {
-      console.log(b("sub commands:"));
-      const s = Array.from(
-        new Map(
-          [...this.$children.values()].map((u) => [
-            u.command.$names[0],
-            u.command
-          ])
-        ).values()
-      ), c = Math.max(...s.map((u) => u.$names[0].length));
-      for (const u of s) {
-        const h = `  ${v(i(u.$names[0], c + 4))}${O(u.$description) ?? ""}`;
-        console.log(h);
-      }
-      console.log(), console.log(
-        `run '${v(`${this.fullCommandPath()} <command> --help`)}' for more info on a command.`
-      );
+    /**
+     * Runs a command.
+     * @param argv The arguments to run the command with. Defaults to your runtime's `argv` equivalent.
+     * @returns this
+     */
+    async run(argv) {
+        if (!argv) {
+            argv =
+                typeof Bun !== "undefined"
+                    ? Bun.argv.slice(2)
+                    : typeof Deno !== "undefined"
+                        ? Deno.args
+                        : process.argv.slice(2);
+        }
+        const result = await this.parse(argv);
+        if (result.isHelp) {
+            result.command.handleErrors([new HelpAskedError(result.command)]);
+            return this;
+        }
+        else if (result.isVersion) {
+            console.log(`${result.command.fullCommandPath()} version ${result.command.$version}`);
+            return this;
+        }
+        try {
+            if (result.errors.length > 0) {
+                await result.command.handleErrors(result.errors, result.input);
+            }
+            else if (!result.command.$fn) {
+                await result.command.handleErrors([new HelpAskedError(result.command), ...result.errors], result.input);
+            }
+            else {
+                const middlewares = collectMiddlewares(result.command);
+                if (middlewares.length > 0) {
+                    const runner = compose(middlewares);
+                    // finalNext calls the command action with the same input
+                    await runner(result.input, async () => {
+                        await result.command.$fn?.(result.input);
+                    });
+                }
+                else {
+                    await result.command.$fn(result.input);
+                }
+            }
+        }
+        catch (e) {
+            if (!(e instanceof Error)) {
+                console.warn("[convoker] an error that is not instance of `Error` was thrown. this may cause undefined behavior.");
+            }
+            await result.command.handleErrors([e]);
+        }
+        return this;
     }
-  }
-  /**
-   * Handles a set of errors.
-   * @param errors The errors to handle.
-   * @param input The parsed input, if possible.
-   * @returns this
-   */
-  async handleErrors(e, t) {
-    let r = this;
-    for (; !r.$errorFn && r.$parent; )
-      r = r.$parent;
-    return r.$errorFn ? await r.$errorFn(r, e, t ?? {}) : this.defaultErrorScreen(e), this;
-  }
-  /**
-   * Runs a command.
-   * @param argv The arguments to run the command with. Defaults to your runtime's `argv` equivalent.
-   * @returns this
-   */
-  async run(e) {
-    e || (e = typeof Bun < "u" ? Bun.argv.slice(2) : typeof Deno < "u" ? Deno.args : process.argv.slice(2));
-    const t = await this.parse(e);
-    if (t.isHelp)
-      return t.command.handleErrors([new P(t.command)]), this;
-    if (t.isVersion)
-      return console.log(
-        `${t.command.fullCommandPath()} version ${t.command.$version}`
-      ), this;
-    try {
-      t.errors.length > 0 ? await t.command.handleErrors(t.errors, t.input) : t.command.$fn ? await t.command.$fn(t.input) : await t.command.handleErrors(
-        [new P(t.command), ...t.errors],
-        t.input
-      );
-    } catch (r) {
-      r instanceof Error || console.warn(
-        "[convoker] an error that is not instance of `Error` was thrown. this may cause undefined behavior."
-      ), await t.command.handleErrors([r]);
+}
+function collectMiddlewares(cmd) {
+    const middlewares = [];
+    let current = cmd;
+    while (current) {
+        if (current.$middlewares.length) {
+            middlewares.unshift(...current.$middlewares);
+        }
+        current = current.$parent;
     }
-    return this;
-  }
+    return middlewares;
+}
+function compose(mws) {
+    return (input, finalNext) => {
+        let index = -1;
+        const dispatch = (i) => {
+            if (i <= index)
+                return Promise.reject(new Error("next() called multiple times"));
+            index = i;
+            const fn = mws[i];
+            if (!fn) {
+                // when middlewares exhausted call finalNext if provided
+                return finalNext ? finalNext() : Promise.resolve();
+            }
+            try {
+                return Promise.resolve(fn(input, () => dispatch(i + 1)));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        };
+        return dispatch(0);
+    };
 }
-export {
-  F as Command,
-  ct as l
-};