356 lines
11 KiB
JavaScript
356 lines
11 KiB
JavaScript
|
import { parseArgs as e } from "node:util";
|
||
|
|
const t = /\d/, n = [
|
||
|
|
`-`,
|
||
|
|
`_`,
|
||
|
|
`/`,
|
||
|
|
`.`
|
||
|
|
];
|
||
|
|
function r(e = ``) {
|
||
|
|
if (!t.test(e)) return e !== e.toLowerCase();
|
||
|
|
}
|
||
|
|
function i(e, t) {
|
||
|
|
let i = t ?? n, a = [];
|
||
|
|
if (!e || typeof e != `string`) return a;
|
||
|
|
let o = ``, s, c;
|
||
|
|
for (let t of e) {
|
||
|
|
let e = i.includes(t);
|
||
|
|
if (e === !0) {
|
||
|
|
a.push(o), o = ``, s = void 0;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
let n = r(t);
|
||
|
|
if (c === !1) {
|
||
|
|
if (s === !1 && n === !0) {
|
||
|
|
a.push(o), o = t, s = n;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (s === !0 && n === !1 && o.length > 1) {
|
||
|
|
let e = o.at(-1);
|
||
|
|
a.push(o.slice(0, Math.max(0, o.length - 1))), o = e + t, s = n;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
o += t, s = n, c = e;
|
||
|
|
}
|
||
|
|
return a.push(o), a;
|
||
|
|
}
|
||
|
|
function a(e) {
|
||
|
|
return e ? e[0].toUpperCase() + e.slice(1) : ``;
|
||
|
|
}
|
||
|
|
function o(e) {
|
||
|
|
return e ? e[0].toLowerCase() + e.slice(1) : ``;
|
||
|
|
}
|
||
|
|
function s(e, t) {
|
||
|
|
return e ? (Array.isArray(e) ? e : i(e)).map((e) => a(t?.normalize ? e.toLowerCase() : e)).join(``) : ``;
|
||
|
|
}
|
||
|
|
function c(e, t) {
|
||
|
|
return o(s(e || ``, t));
|
||
|
|
}
|
||
|
|
function l(e, t) {
|
||
|
|
return e ? (Array.isArray(e) ? e : i(e)).map((e) => e.toLowerCase()).join(t ?? `-`) : ``;
|
||
|
|
}
|
||
|
|
function u(e) {
|
||
|
|
return l(e || ``, `_`);
|
||
|
|
}
|
||
|
|
function d(e) {
|
||
|
|
return Array.isArray(e) ? e : e === void 0 ? [] : [e];
|
||
|
|
}
|
||
|
|
function f(e, t = ``) {
|
||
|
|
let n = [];
|
||
|
|
for (let t of e) for (let [e, r] of t.entries()) n[e] = Math.max(n[e] || 0, r.length);
|
||
|
|
return e.map((e) => e.map((e, r) => t + e[r === 0 ? `padStart` : `padEnd`](n[r])).join(` `)).join(`
|
||
|
|
`);
|
||
|
|
}
|
||
|
|
function p(e) {
|
||
|
|
return typeof e == `function` ? e() : e;
|
||
|
|
}
|
||
|
|
var m = class extends Error {
|
||
|
|
code;
|
||
|
|
constructor(e, t) {
|
||
|
|
super(e), this.name = `CLIError`, this.code = t;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function h(t = [], n = {}) {
|
||
|
|
let r = new Set(n.boolean || []), i = new Set(n.string || []), a = n.alias || {}, o = n.default || {}, s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
|
||
|
|
for (let [e, t] of Object.entries(a)) {
|
||
|
|
let n = t;
|
||
|
|
for (let t of n) s.set(e, t), c.has(t) || c.set(t, []), c.get(t).push(e), s.set(t, e), c.has(e) || c.set(e, []), c.get(e).push(t);
|
||
|
|
}
|
||
|
|
let l = {};
|
||
|
|
function u(e) {
|
||
|
|
if (r.has(e)) return `boolean`;
|
||
|
|
let t = c.get(e) || [];
|
||
|
|
for (let e of t) if (r.has(e)) return `boolean`;
|
||
|
|
return `string`;
|
||
|
|
}
|
||
|
|
function d(e) {
|
||
|
|
if (i.has(e)) return !0;
|
||
|
|
let t = c.get(e) || [];
|
||
|
|
for (let e of t) if (i.has(e)) return !0;
|
||
|
|
return !1;
|
||
|
|
}
|
||
|
|
let f = /* @__PURE__ */ new Set([
|
||
|
|
...r,
|
||
|
|
...i,
|
||
|
|
...Object.keys(a),
|
||
|
|
...Object.values(a).flat(),
|
||
|
|
...Object.keys(o)
|
||
|
|
]);
|
||
|
|
for (let e of f) l[e] || (l[e] = {
|
||
|
|
type: u(e),
|
||
|
|
default: o[e]
|
||
|
|
});
|
||
|
|
for (let [e, t] of s.entries()) e.length === 1 && l[t] && !l[t].short && (l[t].short = e);
|
||
|
|
let p = [], m = {};
|
||
|
|
for (let e = 0; e < t.length; e++) {
|
||
|
|
let n = t[e];
|
||
|
|
if (n === `--`) {
|
||
|
|
p.push(...t.slice(e));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (n.startsWith(`--no-`)) {
|
||
|
|
let e = n.slice(5);
|
||
|
|
m[e] = !0;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
p.push(n);
|
||
|
|
}
|
||
|
|
let h;
|
||
|
|
try {
|
||
|
|
h = e({
|
||
|
|
args: p,
|
||
|
|
options: Object.keys(l).length > 0 ? l : void 0,
|
||
|
|
allowPositionals: !0,
|
||
|
|
strict: !1
|
||
|
|
});
|
||
|
|
} catch {
|
||
|
|
h = {
|
||
|
|
values: {},
|
||
|
|
positionals: p
|
||
|
|
};
|
||
|
|
}
|
||
|
|
let g = { _: [] };
|
||
|
|
g._ = h.positionals;
|
||
|
|
for (let [e, t] of Object.entries(h.values)) {
|
||
|
|
let n = t;
|
||
|
|
u(e) === `boolean` && typeof t == `string` ? n = t !== `false` : d(e) && typeof t == `boolean` && (n = ``), g[e] = n;
|
||
|
|
}
|
||
|
|
for (let [e] of Object.entries(m)) {
|
||
|
|
g[e] = !1;
|
||
|
|
let t = s.get(e);
|
||
|
|
t && (g[t] = !1);
|
||
|
|
let n = c.get(e);
|
||
|
|
if (n) for (let e of n) g[e] = !1;
|
||
|
|
}
|
||
|
|
for (let [e, t] of s.entries()) g[e] !== void 0 && g[t] === void 0 && (g[t] = g[e]), g[t] !== void 0 && g[e] === void 0 && (g[e] = g[t]), g[e] !== g[t] && o[t] === g[t] && (g[t] = g[e]);
|
||
|
|
return g;
|
||
|
|
}
|
||
|
|
const g = (() => {
|
||
|
|
let e = globalThis.process?.env ?? {};
|
||
|
|
return e.NO_COLOR === `1` || e.TERM === `dumb` || e.TEST || e.CI;
|
||
|
|
})(), _ = (e, t = 39) => (n) => g ? n : `\u001B[${e}m${n}\u001B[${t}m`, v = _(1, 22), y = _(36), b = _(90), x = _(4, 24);
|
||
|
|
function S(e, t) {
|
||
|
|
let n = {
|
||
|
|
boolean: [],
|
||
|
|
string: [],
|
||
|
|
alias: {},
|
||
|
|
default: {}
|
||
|
|
}, r = C(t);
|
||
|
|
for (let e of r) {
|
||
|
|
if (e.type === `positional`) continue;
|
||
|
|
e.type === `string` || e.type === `enum` ? n.string.push(e.name) : e.type === `boolean` && n.boolean.push(e.name), e.default !== void 0 && (n.default[e.name] = e.default), e.alias && (n.alias[e.name] = e.alias);
|
||
|
|
let t = c(e.name), r = l(e.name);
|
||
|
|
if (t !== e.name || r !== e.name) {
|
||
|
|
let i = d(n.alias[e.name] || []);
|
||
|
|
t !== e.name && !i.includes(t) && i.push(t), r !== e.name && !i.includes(r) && i.push(r), i.length > 0 && (n.alias[e.name] = i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
let i = h(e, n), [ ...a] = i._, o = new Proxy(i, { get(e, t) {
|
||
|
|
return e[t] ?? e[c(t)] ?? e[l(t)];
|
||
|
|
} });
|
||
|
|
for (let [, e] of r.entries()) if (e.type === `positional`) {
|
||
|
|
let t = a.shift();
|
||
|
|
if (t !== void 0) o[e.name] = t;
|
||
|
|
else if (e.default === void 0 && e.required !== !1) throw new m(`Missing required positional argument: ${e.name.toUpperCase()}`, `EARG`);
|
||
|
|
else o[e.name] = e.default;
|
||
|
|
} else if (e.type === `enum`) {
|
||
|
|
let t = o[e.name], n = e.options || [];
|
||
|
|
if (t !== void 0 && n.length > 0 && !n.includes(t)) throw new m(`Invalid value for argument: ${y(`--${e.name}`)} (${y(t)}). Expected one of: ${n.map((e) => y(e)).join(`, `)}.`, `EARG`);
|
||
|
|
} else if (e.required && o[e.name] === void 0) throw new m(`Missing required argument: --${e.name}`, `EARG`);
|
||
|
|
return o;
|
||
|
|
}
|
||
|
|
function C(e) {
|
||
|
|
let t = [];
|
||
|
|
for (let [n, r] of Object.entries(e || {})) t.push({
|
||
|
|
...r,
|
||
|
|
name: n,
|
||
|
|
alias: d(r.alias)
|
||
|
|
});
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
async function w(e) {
|
||
|
|
return Promise.all(e.map((e) => p(e)));
|
||
|
|
}
|
||
|
|
function T(e) {
|
||
|
|
return e;
|
||
|
|
}
|
||
|
|
async function E(e, t) {
|
||
|
|
let n = await p(e.args || {}), r = S(t.rawArgs, n), i = {
|
||
|
|
rawArgs: t.rawArgs,
|
||
|
|
args: r,
|
||
|
|
data: t.data,
|
||
|
|
cmd: e
|
||
|
|
}, a = await w(e.plugins ?? []), o, s;
|
||
|
|
try {
|
||
|
|
for (let e of a) await e.setup?.(i);
|
||
|
|
typeof e.setup == `function` && await e.setup(i);
|
||
|
|
let r = await p(e.subCommands);
|
||
|
|
if (r && Object.keys(r).length > 0) {
|
||
|
|
let i = k(t.rawArgs, n), a = t.rawArgs[i];
|
||
|
|
if (a) {
|
||
|
|
let e = await O(r, a);
|
||
|
|
if (!e) throw new m(`Unknown command ${y(a)}`, `E_UNKNOWN_COMMAND`);
|
||
|
|
await E(e, { rawArgs: t.rawArgs.slice(i + 1) });
|
||
|
|
} else {
|
||
|
|
let n = await p(e.default);
|
||
|
|
if (n) {
|
||
|
|
if (e.run) throw new m(`Cannot specify both 'run' and 'default' on the same command.`, `E_DEFAULT_CONFLICT`);
|
||
|
|
let i = await O(r, n);
|
||
|
|
if (!i) throw new m(`Default sub command ${y(n)} not found in subCommands.`, `E_UNKNOWN_COMMAND`);
|
||
|
|
await E(i, { rawArgs: t.rawArgs });
|
||
|
|
} else if (!e.run) throw new m(`No command specified.`, `E_NO_COMMAND`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
typeof e.run == `function` && (o = await e.run(i));
|
||
|
|
} catch (e) {
|
||
|
|
s = e;
|
||
|
|
}
|
||
|
|
let c = [];
|
||
|
|
if (typeof e.cleanup == `function`) try {
|
||
|
|
await e.cleanup(i);
|
||
|
|
} catch (e) {
|
||
|
|
c.push(e);
|
||
|
|
}
|
||
|
|
for (let e of [...a].reverse()) try {
|
||
|
|
await e.cleanup?.(i);
|
||
|
|
} catch (e) {
|
||
|
|
c.push(e);
|
||
|
|
}
|
||
|
|
if (s) throw s;
|
||
|
|
if (c.length === 1) throw c[0];
|
||
|
|
if (c.length > 1) throw Error(`Multiple cleanup errors`, { cause: c });
|
||
|
|
return { result: o };
|
||
|
|
}
|
||
|
|
async function D(e, t, n) {
|
||
|
|
let r = await p(e.subCommands);
|
||
|
|
if (r && Object.keys(r).length > 0) {
|
||
|
|
let n = k(t, await p(e.args || {})), i = t[n], a = await O(r, i);
|
||
|
|
if (a) return D(a, t.slice(n + 1), e);
|
||
|
|
}
|
||
|
|
return [e, n];
|
||
|
|
}
|
||
|
|
async function O(e, t) {
|
||
|
|
if (t in e) return p(e[t]);
|
||
|
|
for (let n of Object.values(e)) {
|
||
|
|
let e = await p(n), r = await p(e?.meta);
|
||
|
|
if (r?.alias && d(r.alias).includes(t)) return e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function k(e, t) {
|
||
|
|
for (let n = 0; n < e.length; n++) {
|
||
|
|
let r = e[n];
|
||
|
|
if (r === `--`) return -1;
|
||
|
|
if (r.startsWith(`-`)) {
|
||
|
|
!r.includes(`=`) && A(r, t) && n++;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
return n;
|
||
|
|
}
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
function A(e, t) {
|
||
|
|
let n = e.replace(/^-{1,2}/, ``), r = c(n);
|
||
|
|
for (let [e, i] of Object.entries(t)) if ((i.type === `string` || i.type === `enum`) && (r === c(e) || (Array.isArray(i.alias) ? i.alias : i.alias ? [i.alias] : []).includes(n))) return !0;
|
||
|
|
return !1;
|
||
|
|
}
|
||
|
|
async function j(e, t) {
|
||
|
|
try {
|
||
|
|
console.log(await N(e, t) + `
|
||
|
|
`);
|
||
|
|
} catch (e) {
|
||
|
|
console.error(e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const M = /^no[-A-Z]/;
|
||
|
|
async function N(e, t) {
|
||
|
|
let n = await p(e.meta || {}), r = C(await p(e.args || {})), i = await p(t?.meta || {}), a = `${i.name ? `${i.name} ` : ``}` + (n.name || process.argv[1]), o = [], s = [], c = [], l = [];
|
||
|
|
for (let e of r) if (e.type === `positional`) {
|
||
|
|
let t = e.name.toUpperCase(), n = e.required !== !1 && e.default === void 0;
|
||
|
|
s.push([y(t + P(e)), F(e, n)]), l.push(n ? `<${t}>` : `[${t}]`);
|
||
|
|
} else {
|
||
|
|
let t = e.required === !0 && e.default === void 0, n = [...(e.alias || []).map((e) => `-${e}`), `--${e.name}`].join(`, `) + P(e);
|
||
|
|
if (o.push([y(n), F(e, t)]), e.type === `boolean` && (e.default === !0 || e.negativeDescription) && !M.test(e.name)) {
|
||
|
|
let n = [...(e.alias || []).map((e) => `--no-${e}`), `--no-${e.name}`].join(`, `);
|
||
|
|
o.push([y(n), [e.negativeDescription, t ? b(`(Required)`) : ``].filter(Boolean).join(` `)]);
|
||
|
|
}
|
||
|
|
t && l.push(`--${e.name}` + P(e));
|
||
|
|
}
|
||
|
|
if (e.subCommands) {
|
||
|
|
let t = [], n = await p(e.subCommands);
|
||
|
|
for (let [e, r] of Object.entries(n)) {
|
||
|
|
let n = await p((await p(r))?.meta);
|
||
|
|
if (n?.hidden) continue;
|
||
|
|
let i = d(n?.alias), a = [e, ...i].join(`, `);
|
||
|
|
c.push([y(a), n?.description || ``]), t.push(e, ...i);
|
||
|
|
}
|
||
|
|
l.push(t.join(`|`));
|
||
|
|
}
|
||
|
|
let u = [], m = n.version || i.version;
|
||
|
|
u.push(b(`${n.description} (${a + (m ? ` v${m}` : ``)})`), ``);
|
||
|
|
let h = o.length > 0 || s.length > 0;
|
||
|
|
return u.push(`${x(v(`USAGE`))} ${y(`${a}${h ? ` [OPTIONS]` : ``} ${l.join(` `)}`)}`, ``), s.length > 0 && (u.push(x(v(`ARGUMENTS`)), ``), u.push(f(s, ` `)), u.push(``)), o.length > 0 && (u.push(x(v(`OPTIONS`)), ``), u.push(f(o, ` `)), u.push(``)), c.length > 0 && (u.push(x(v(`COMMANDS`)), ``), u.push(f(c, ` `)), u.push(``, `Use ${y(`${a} <command> --help`)} for more information about a command.`)), u.filter((e) => typeof e == `string`).join(`
|
||
|
|
`);
|
||
|
|
}
|
||
|
|
function P(e) {
|
||
|
|
let t = e.valueHint ? `=<${e.valueHint}>` : ``, n = t || `=<${u(e.name)}>`;
|
||
|
|
return !e.type || e.type === `positional` || e.type === `boolean` ? t : e.type === `enum` && e.options?.length ? `=<${e.options.join(`|`)}>` : n;
|
||
|
|
}
|
||
|
|
function F(e, t) {
|
||
|
|
let n = t ? b(`(Required)`) : ``, r = e.default === void 0 ? `` : b(`(Default: ${e.default})`);
|
||
|
|
return [
|
||
|
|
e.description,
|
||
|
|
n,
|
||
|
|
r
|
||
|
|
].filter(Boolean).join(` `);
|
||
|
|
}
|
||
|
|
async function I(e, t = {}) {
|
||
|
|
let n = t.rawArgs || process.argv.slice(2), r = t.showUsage || j;
|
||
|
|
try {
|
||
|
|
let t = await L(e);
|
||
|
|
if (t.help.length > 0 && n.some((e) => t.help.includes(e))) await r(...await D(e, n)), process.exit(0);
|
||
|
|
else if (n.length === 1 && t.version.includes(n[0])) {
|
||
|
|
let t = typeof e.meta == `function` ? await e.meta() : await e.meta;
|
||
|
|
if (!t?.version) throw new m(`No version specified`, `E_NO_VERSION`);
|
||
|
|
console.log(t.version);
|
||
|
|
} else await E(e, { rawArgs: n });
|
||
|
|
} catch (t) {
|
||
|
|
t instanceof m ? (await r(...await D(e, n)), console.error(t.message)) : console.error(t, `
|
||
|
|
`), process.exit(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function L(e) {
|
||
|
|
let t = await p(e.args || {}), n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
|
||
|
|
for (let [e, i] of Object.entries(t)) {
|
||
|
|
n.add(e);
|
||
|
|
for (let e of d(i.alias)) r.add(e);
|
||
|
|
}
|
||
|
|
return {
|
||
|
|
help: R(`help`, `h`, n, r),
|
||
|
|
version: R(`version`, `v`, n, r)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function R(e, t, n, r) {
|
||
|
|
return n.has(e) || r.has(e) ? [] : n.has(t) || r.has(t) ? [`--${e}`] : [`--${e}`, `-${t}`];
|
||
|
|
}
|
||
|
|
export { T as defineCommand, I as runMain };
|