convoker 0.1.0

package/dist/command.js

@@ -0,0 +1,415 @@
+import { D as L, b, c as v, g as M } from "./chunks/color-CiruG_zQ.js";
+import { s as V } from "./chunks/index-G2nVXKup.js";
+import { m as q, i as O, b as W, a as j } from "./chunks/utils-DdmSEjLc.js";
+import { M as R, a as z, L as N, H as A, U as J } from "./chunks/error-Cj2qDfOl.js";
+import { P as B, c as K, O as H } from "./chunks/input-COjWPD53.js";
+async function G() {
+  if (W && process.stdout?.writable) {
+    const { Writable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((t) => t._);
+    return n.toWeb(process.stdout);
+  }
+  return O && Deno.stdout?.writable ? Deno.stdout.writable : j && Bun.stdout ? Bun.stdout : new WritableStream({
+    write(n) {
+      console.log(String(n));
+    }
+  });
+}
+async function Q() {
+  if (W && process.stderr?.writable) {
+    const { Writable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((t) => t._);
+    return n.toWeb(process.stderr);
+  }
+  return O && Deno.stderr?.writable ? Deno.stderr.writable : j && Bun.stderr ? Bun.stderr : new WritableStream({
+    write(n) {
+      console.error(String(n));
+    }
+  });
+}
+async function X() {
+  if (W && process.stdin?.readable) {
+    const { Readable: n } = await import("./chunks/__vite-browser-external-DQYBmsno.js").then((t) => t._);
+    return n.toWeb(process.stdin);
+  }
+  return O && Deno.stdin?.readable ? Deno.stdin.readable : j ? Bun.stdin.stream() : new ReadableStream({
+    start(n) {
+      n.close();
+    }
+  });
+}
+let m = L, g;
+function I(n) {
+  m = n;
+}
+async function T(n) {
+  g = q(
+    {
+      format: "text",
+      stdout: await G(),
+      stderr: await Q(),
+      stdin: await X()
+    },
+    n
+  );
+}
+async function Y() {
+  await T({});
+}
+function S(n, ...t) {
+  const e = (/* @__PURE__ */ new Date()).toISOString(), r = t.map((o) => typeof o == "string" ? o : JSON.stringify(o, null, 2)).join(" ");
+  switch (g.format) {
+    case "json":
+      return JSON.stringify({ timestamp: e, level: n, message: r }) + `
+`;
+    case "xml":
+      return `<log>
+  <timestamp>${e}</timestamp>
+  <level>${n}</level>
+  <message>${r}</message>
+</log>
+`;
+    case "yaml":
+      return `- timestamp: ${e}
+  level: ${n}
+  message: "${r.replace(/"/g, '\\"')}"
+`;
+    case "csv":
+      return `"${e}","${n}","${r.replace(/"/g, '""')}"
+`;
+    case "text":
+    default:
+      return `[${e}] [${n.toUpperCase()}] ${r}
+`;
+  }
+}
+function E(n, t) {
+  switch (n) {
+    case "trace":
+      return m.secondary ? m.secondary(t) : t;
+    case "info":
+      return m.info ? m.info(t) : t;
+    case "warn":
+      return m.warning ? m.warning(t) : t;
+    case "error":
+      return m.error ? m.error(t) : t;
+    case "fatal":
+      return m.error ? m.error(m.styles?.bold?.(t) ?? t) : t;
+    default:
+      return t;
+  }
+}
+async function k(n, t) {
+  const e = n.getWriter();
+  try {
+    await e.write(t);
+  } finally {
+    e.releaseLock();
+  }
+}
+async function Z(...n) {
+  const t = S("trace", ...n), e = E("trace", t);
+  await k(g.stdout, e);
+}
+async function x(...n) {
+  const t = S("info", ...n), e = E("info", t);
+  await k(g.stdout, e);
+}
+async function tt(...n) {
+  const t = S("warn", ...n), e = E("warn", t);
+  await k(g.stdout, e);
+}
+async function et(...n) {
+  const t = S("error", ...n), e = E("error", t);
+  await k(g.stderr, e);
+}
+async function nt(...n) {
+  const t = S("fatal", ...n), e = E("fatal", t);
+  await k(g.stderr, e), O ? Deno.exit(-1) : (W || j) && process.exit(-1);
+}
+const ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  error: et,
+  fatal: nt,
+  info: x,
+  setConfig: T,
+  setTheme: I,
+  setup: Y,
+  trace: Z,
+  warn: tt
+}, Symbol.toStringTag, { value: "Module" }));
+class F {
+  /**
+   * Creates a new command.
+   * @param names The names (aliases).
+   * @param desc The description.
+   * @param version The version.
+   */
+  constructor(t, e, r) {
+    this.$children = /* @__PURE__ */ new Map(), this.$allowUnknownOptions = !1, this.$input = {}, this.$fn = void 0, this.$errorFn = void 0, this.$names = Array.isArray(t) ? t : [t], this.$description = e, this.$version = r;
+  }
+  /**
+   * Adds a set of aliases to this command.
+   * @param aliases The aliases to add.
+   * @returns this
+   */
+  alias(...t) {
+    return this.$names.concat(t), this.$parent?.add(this), this;
+  }
+  /**
+   * Adds a description to this command.
+   * @param desc The description.
+   * @returns this
+   */
+  description(t) {
+    return this.$description = t, this;
+  }
+  /**
+   * Adds a version to this command.
+   * @param version The version.
+   * @returns this
+   */
+  version(t) {
+    return this.$version = t, this;
+  }
+  /**
+   * Sets the input for this command.
+   * @param version The input.
+   * @returns this
+   */
+  input(t) {
+    return this.$input = t, this;
+  }
+  /**
+   * Sets the action function for this command.
+   * @param fn The action.
+   * @returns this
+   */
+  action(t) {
+    return this.$fn = t, this;
+  }
+  /**
+   * Sets the error function for this command.
+   * @param fn The error handler.
+   * @returns this
+   */
+  error(t) {
+    return this.$errorFn = t, this;
+  }
+  /**
+   * Adds an existing command to this.
+   * @param command The command.
+   * @returns this
+   */
+  add(t) {
+    t.$parent = this;
+    const e = { command: t, alias: t.$names[0] };
+    for (let r = 0; r < t.$names.length; r++)
+      r === 0 && this.$children.set(t.$names[r], { command: t }), this.$children.set(t.$names[r], e);
+    return this;
+  }
+  subCommand(t, e, r) {
+    if (typeof e == "function") {
+      const c = new F(t);
+      return e(c), this.add(c), this;
+    }
+    const o = new F(t, e, r);
+    return this.add(o), o;
+  }
+  /**
+   * 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(t) {
+    let e = this, r = !1;
+    const o = {}, c = [], d = {}, s = [], a = e.buildInputMap();
+    function u(f, i) {
+      const l = a.get(f);
+      return l ? l.value : (!e.$allowUnknownOptions && !i && s.push(new J(e, f)), null);
+    }
+    function p(f, i, l) {
+      i.$kind === "boolean" ? d[f] = "true" : l !== void 0 && (d[f] = l);
+    }
+    let h = !1, C = !1;
+    for (let f = 0; f < t.length; f++) {
+      const i = t[f];
+      if (i.startsWith("--")) {
+        const [l, w] = i.slice(2).split("=");
+        let y = !1;
+        l === "help" ? (C = !0, y = !0) : l === "version" && (h = !0, y = !0);
+        const $ = u(l, y);
+        $ && (w === void 0 ? p(
+          l,
+          $,
+          $.$kind === "boolean" ? void 0 : t[++f]
+        ) : p(l, $, w));
+      } else if (i.startsWith("-")) {
+        const [l, w] = i.slice(1).split("="), y = l.split("");
+        let $ = w;
+        for (const D of y) {
+          let U = !1;
+          D === "h" ? (C = !0, U = !0) : D === "V" && (h = !0, U = !0);
+          const P = u(D, U);
+          P && (P.$kind !== "boolean" && $ === void 0 && ($ = t[++f]), p(D, P, $), $ = void 0);
+        }
+      } else
+        e.$children.has(i) && !r ? (e = e.$children.get(i).command, e.$theme && (V(e.$theme), I(e.$theme))) : (r = !0, c.push(i));
+    }
+    let _ = 0;
+    for (const f in e.$input) {
+      const i = e.$input[f];
+      let l;
+      if (i instanceof B)
+        l = c[_++];
+      else
+        for (const w of i.$names)
+          if (d[w] !== void 0) {
+            l = d[w];
+            break;
+          }
+      l !== void 0 ? o[f] = await K(i.$kind, l) : i.$default !== void 0 ? o[f] = i.$default : i.$required && (i instanceof H ? s.push(new R(e, f, i)) : s.push(new z(e, f, i)));
+    }
+    return {
+      input: o,
+      command: e,
+      errors: s,
+      isVersion: h,
+      isHelp: C
+    };
+  }
+  buildInputMap(t) {
+    const e = /* @__PURE__ */ new Map();
+    let r = 0;
+    for (const o in this.$input) {
+      const c = this.$input[o];
+      if (c instanceof B)
+        e.set(r++, { value: c, key: o });
+      else
+        for (const d of c.$names)
+          e.set(d, { value: c, key: o });
+    }
+    if (!t)
+      for (const [o, c] of this.$parent?.buildInputMap() ?? [])
+        e.set(o, c);
+    for (const [, { command: o }] of this.$children)
+      for (const [c, d] of o.buildInputMap(!0))
+        e.set(c, d);
+    return e;
+  }
+  /**
+   * Gets the full command path (name including parents).
+   * @returns The full command path.
+   */
+  fullCommandPath() {
+    const t = [];
+    let e = this;
+    for (; e; )
+      t.unshift(e.$names[0]), e = e.$parent;
+    return t.join(" ");
+  }
+  /**
+   * The default error screen.
+   * @param errors The errors.
+   */
+  defaultErrorScreen(t) {
+    let e = !1;
+    const r = [];
+    for (const s of t)
+      s instanceof N ? (s instanceof A || s.print(), e = !0) : r.push(s);
+    if (r.length) throw r[0];
+    if (!e) return;
+    const o = (s, a) => s.padEnd(a, " ");
+    console.log(
+      `${b("usage:")} ${v(this.fullCommandPath())} ${M("[options] [arguments]")}`
+    ), this.$description && console.log(`${this.$description}`), this.$version && console.log(`${b("version")} ${this.$version}`);
+    const c = Object.entries(this.$input).filter(([, s]) => s instanceof H).map(([s, a]) => ({ key: s, entry: a }));
+    if (c.length > 0) {
+      console.log(b("options:"));
+      const s = Math.max(
+        ...c.map(({ entry: a }) => a.$names.join(", ").length)
+      );
+      for (const { entry: a } of c) {
+        const u = a.$names.map((h) => h.length === 1 ? `-${h}` : `--${h}`).join(", "), p = `  ${v(o(u, s + 4))}${M(a.$description ?? "")}`;
+        console.log(p);
+      }
+    }
+    const d = Object.entries(this.$input).filter(([, s]) => s instanceof B).map(([s, a]) => ({
+      key: s,
+      entry: a
+    }));
+    if (d.length > 0) {
+      console.log(b("arguments:"));
+      const s = Math.max(...d.map(({ key: a }) => a.length));
+      for (const { key: a, entry: u } of d) {
+        const p = u.$required ? `<${a}>` : `[${a}]`, h = `  ${v(o(p, s + 4))}${M(u.$description ?? "")}`;
+        console.log(h);
+      }
+    }
+    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()
+      ), a = Math.max(...s.map((u) => u.$names[0].length));
+      for (const u of s) {
+        const p = `  ${v(o(u.$names[0], a + 4))}${M(u.$description) ?? ""}`;
+        console.log(p);
+      }
+      console.log(), console.log(
+        `run '${v(`${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(t, e) {
+    let r = this;
+    for (; !r.$errorFn && r.$parent; )
+      r = r.$parent;
+    return r.$errorFn ? await r.$errorFn(r, t, e ?? {}) : this.defaultErrorScreen(t), this;
+  }
+  /**
+   * Runs a command.
+   * @param argv The arguments to run the command with. Defaults to your runtime's `argv` equivalent.
+   * @returns this
+   */
+  async run(t) {
+    t || (t = typeof Bun < "u" ? Bun.argv.slice(2) : typeof Deno < "u" ? Deno.args : process.argv.slice(2));
+    const e = await this.parse(t);
+    if (e.isHelp)
+      return e.command.handleErrors([new A(e.command)]), this;
+    if (e.isVersion)
+      return console.log(
+        `${e.command.fullCommandPath()} version ${e.command.$version}`
+      ), this;
+    try {
+      e.errors.length > 0 ? await e.command.handleErrors(e.errors, e.input) : e.command.$fn ? await e.command.$fn(e.input) : await e.command.handleErrors(
+        [new A(e.command), ...e.errors],
+        e.input
+      );
+    } catch (r) {
+      r instanceof Error || console.warn(
+        "[lunarcli] an error that is not instance of `Error` was thrown. this may cause undefined behavior."
+      ), await e.command.handleErrors([r]);
+    }
+    return this;
+  }
+}
+export {
+  F as Command,
+  ct as l
+};