convoker 0.3.2 → 0.3.4

package/dist/command-D2UiQBNA.mjs

@@ -0,0 +1,583 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
+import { i as merge, n as isDeno, r as isNode, t as isBun } from "./utils-ChmY93uA.mjs";
+import { O as gray, t as DEFAULT_THEME, w as cyan, x as bold } from "./color-OlJQTTxb.mjs";
+import { a as MissingRequiredOptionError, i as MissingRequiredArgumentError, n as HelpAskedError, o as TooManyArgumentsError, s as UnknownOptionError, t as ConvokerError } from "./error-C1S1gs8L.mjs";
+import { c as setTheme } from "./prompt-Cvufljin.mjs";
+import { i as convert, n as Positional, t as Option } from "./input-DRy_sVxZ.mjs";
+
+//#region src/log.ts
+var log_exports = /* @__PURE__ */ __export({
+	error: () => error,
+	fatal: () => fatal,
+	info: () => info,
+	setConfig: () => setConfig,
+	setTheme: () => setTheme$1,
+	setup: () => setup,
+	trace: () => trace,
+	warn: () => warn
+});
+/**
+* Gets the default stdout, in a cross-runtime way.
+* @returns The default stdout.
+*/
+async function getDefaultStdout() {
+	if (isNode && process.stdout?.writable) {
+		const { Writable } = await import("node:stream");
+		return Writable.toWeb(process.stdout);
+	}
+	if (isDeno && Deno.stdout?.writable) return Deno.stdout.writable;
+	if (isBun && Bun.stdout) return Bun.stdout;
+	return new WritableStream({ write(chunk) {
+		console.log(String(chunk));
+	} });
+}
+/**
+* Gets the default stderr, in a cross-runtime way.
+* @returns The default stderr.
+*/
+async function getDefaultStderr() {
+	if (isNode && process.stderr?.writable) {
+		const { Writable } = await import("node:stream");
+		return Writable.toWeb(process.stderr);
+	}
+	if (isDeno && Deno.stderr?.writable) return Deno.stderr.writable;
+	if (isBun && Bun.stderr) return Bun.stderr;
+	return new WritableStream({ write(chunk) {
+		console.error(String(chunk));
+	} });
+}
+/**
+* Gets the default stdin, in a cross-runtime way.
+* @returns The default stdin.
+*/
+async function getDefaultStdin() {
+	if (isNode && process.stdin?.readable) {
+		const { Readable } = await import("node:stream");
+		return Readable.toWeb(process.stdin);
+	}
+	if (isDeno && Deno.stdin?.readable) return Deno.stdin.readable;
+	if (isBun) return Bun.stdin.stream();
+	return new ReadableStream({ start(controller) {
+		controller.close();
+	} });
+}
+let theme = DEFAULT_THEME;
+let config = void 0;
+/**
+* Sets a new theme.
+* @param t The theme.
+*/
+function setTheme$1(t) {
+	theme = t;
+}
+/**
+* Sets new configuration.
+* @param c The config.
+*/
+async function setConfig(c) {
+	config = merge({
+		format: "text",
+		stdout: await getDefaultStdout(),
+		stderr: await getDefaultStderr(),
+		stdin: await getDefaultStdin()
+	}, c);
+}
+/**
+* Sets default configuration.
+*/
+async function setup() {
+	await setConfig({});
+}
+/**
+* Formats a message to the correct format.
+* @param level The level of mesage.
+* @param msgs The messages to format.
+* @returns The formatted message.
+*/
+function formatMessages(level, ...msgs) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const msg = msgs.map((m) => typeof m === "string" ? m : JSON.stringify(m, null, 2)).join(" ");
+	switch (config.format) {
+		case "json": return JSON.stringify({
+			timestamp,
+			level,
+			message: msg
+		}) + "\n";
+		case "xml": return `<log>
+  <timestamp>${timestamp}</timestamp>
+  <level>${level}</level>
+  <message>${msg}</message>
+</log>\n`;
+		case "yaml": return `- timestamp: ${timestamp}
+  level: ${level}
+  message: "${msg.replace(/"/g, "\\\"")}"\n`;
+		case "csv": return `"${timestamp}","${level}","${msg.replace(/"/g, "\"\"")}"\n`;
+		case "text":
+		default: return `[${timestamp}] [${level.toUpperCase()}] ${msg}\n`;
+	}
+}
+/**
+* Colorizes text.
+* @param level The log level.
+* @param text The text to colorize.
+* @returns The colorized text.
+*/
+function colorize(level, text) {
+	switch (level) {
+		case "trace": return theme.secondary ? theme.secondary(text) : text;
+		case "info": return theme.info ? theme.info(text) : text;
+		case "warn": return theme.warning ? theme.warning(text) : text;
+		case "error": return theme.error ? theme.error(text) : text;
+		case "fatal": return theme.error ? theme.error(theme.styles?.bold?.(text) ?? text) : text;
+		default: return text;
+	}
+}
+/**
+* Writes to a stream.
+* @param stream The stream to write to.
+* @param msg The message to write.
+*/
+async function writeToStream(stream, msg) {
+	const writer = stream.getWriter();
+	try {
+		await writer.write(msg);
+	} finally {
+		writer.releaseLock();
+	}
+}
+/**
+* Prints debug information.
+* @param msgs The messages to write.
+*/
+async function trace(...msgs) {
+	const colored = colorize("trace", formatMessages("trace", ...msgs));
+	await writeToStream(config.stdout, colored);
+}
+/**
+* Prints information.
+* @param msgs The messages to write.
+*/
+async function info(...msgs) {
+	const colored = colorize("info", formatMessages("info", ...msgs));
+	await writeToStream(config.stdout, colored);
+}
+/**
+* Prints warnings.
+* @param msgs The messages to write.
+*/
+async function warn(...msgs) {
+	const colored = colorize("warn", formatMessages("warn", ...msgs));
+	await writeToStream(config.stdout, colored);
+}
+/**
+* Prints errors.
+* @param msgs The messages to write.
+*/
+async function error(...msgs) {
+	const colored = colorize("error", formatMessages("error", ...msgs));
+	await writeToStream(config.stderr, colored);
+}
+/**
+* Prints errors and exits.
+* @param msgs The messages to write.
+*/
+async function fatal(...msgs) {
+	const colored = colorize("fatal", formatMessages("fatal", ...msgs));
+	await writeToStream(config.stderr, colored);
+	if (isDeno) Deno.exit(-1);
+	else if (isNode || isBun) process.exit(-1);
+}
+
+//#endregion
+//#region src/command.ts
+/**
+* A command.
+*/
+var Command = class Command {
+	/**
+	* Creates a new command.
+	* @param names The names (aliases).
+	* @param desc The description.
+	* @param version The version.
+	*/
+	constructor(names, desc, version) {
+		this.$children = /* @__PURE__ */ new Map();
+		this.$allowUnknownOptions = false;
+		this.$allowSurpassArgLimit = false;
+		this.$input = {};
+		this.$fn = void 0;
+		this.$middlewares = [];
+		this.$errorFn = void 0;
+		this.$names = Array.isArray(names) ? names : [names];
+		this.$description = desc;
+		this.$version = version;
+	}
+	/**
+	* 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;
+	}
+	/**
+	* Adds a description to this command.
+	* @param desc The description.
+	* @returns this
+	*/
+	description(desc) {
+		this.$description = desc;
+		return 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;
+	}
+	/**
+	* Sets the action function for this command.
+	* @param fn The action.
+	* @returns this
+	*/
+	action(fn) {
+		this.$fn = fn;
+		return this;
+	}
+	/**
+	* Sets the error function for this command.
+	* @param fn The error handler.
+	* @returns this
+	*/
+	error(fn) {
+		this.$errorFn = fn;
+		return this;
+	}
+	/**
+	* 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);
+		}
+		return this;
+	}
+	subCommand(names, descOrBuilder, version) {
+		if (typeof descOrBuilder === "function") {
+			const command$1 = new Command(names);
+			descOrBuilder(command$1);
+			this.add(command$1);
+			return this;
+		}
+		const command = new Command(names, descOrBuilder, version);
+		this.add(command);
+		return command;
+	}
+	/**
+	* Allows unknown options.
+	* @returns this
+	*/
+	allowUnknownOptions() {
+		this.$allowUnknownOptions = true;
+		return this;
+	}
+	/**
+	* Parses a set of command-line arguments.
+	* @param argv The arguments to parse.
+	* @returns A parse result.
+	*/
+	async parse(argv) {
+		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 !== void 0) opts[key] = value;
+		}
+		let isVersion = false;
+		let isHelp = false;
+		for (let i = 0; i < argv.length; i++) {
+			const arg = argv[i];
+			if (arg.startsWith("--")) {
+				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 === void 0) setOption(key, option, option.$kind === "boolean" ? void 0 : argv[++i]);
+				else setOption(key, option, value);
+			} else if (arg.startsWith("-")) {
+				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 === void 0) usedValue = argv[++i];
+					setOption(char, option, usedValue);
+					usedValue = void 0;
+				}
+			} else if (command.$children.has(arg) && !found) {
+				command = command.$children.get(arg).command;
+				if (command.$theme) {
+					setTheme(command.$theme);
+					setTheme$1(command.$theme);
+				}
+			} else {
+				found = true;
+				args.push(arg);
+			}
+		}
+		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 === void 0 && entry.$required) errors.push(new MissingRequiredArgumentError(command, key, entry));
+			}
+			else for (const name of entry.$names) if (opts[name] !== void 0) {
+				rawValue = entry.$list ? opts[name].split(entry.$separator ?? ",") : opts[name];
+				break;
+			}
+			if (rawValue !== void 0) input[key] = await convert(entry.$kind, rawValue);
+			else if (entry.$default !== void 0) 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));
+		}
+		const remainingArgs = args.slice(index);
+		if (!command.$allowSurpassArgLimit && remainingArgs.length > 0) errors.push(new TooManyArgumentsError(command));
+		return {
+			input,
+			command,
+			errors,
+			isVersion,
+			isHelp
+		};
+	}
+	buildInputMap(ignoreParentMap) {
+		const map = /* @__PURE__ */ 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 = [];
+		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$1 of errors) if (error$1 instanceof ConvokerError) {
+			if (!(error$1 instanceof HelpAskedError)) error$1.print();
+			printHelpScreen = true;
+		} else nonCliErrors.push(error$1);
+		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}`);
+		const opts = Object.entries(this.$input).filter(([, entry]) => entry instanceof Option).map(([key, entry]) => ({
+			key,
+			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 line = `  ${cyan(pad(entry.$names.map((n) => n.length === 1 ? `-${n}` : `--${n}`).join(", "), longest + 4))}${gray(entry.$description ?? "")}`;
+				console.log(line);
+			}
+		}
+		const positionals = Object.entries(this.$input).filter(([, entry]) => entry instanceof Positional).map(([key, entry]) => ({
+			key,
+			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 line = `  ${cyan(pad(entry.$required ? `<${key}>` : `[${key}]`, longest + 4))}${gray(entry.$description ?? "")}`;
+				console.log(line);
+			}
+		}
+		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) {
+		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;
+	}
+	/**
+	* 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) await compose(middlewares)(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;
+	}
+};
+function collectMiddlewares(cmd) {
+	const middlewares = [];
+	let current = cmd;
+	while (current) {
+		if (current.$middlewares.length) middlewares.unshift(...current.$middlewares);
+		current = current.$parent;
+	}
+	return middlewares;
+}
+function compose(mws) {
+	return (input, finalNext) => {
+		let index = -1;
+		const dispatch = (i) => {
+			if (i <= index) return Promise.reject(/* @__PURE__ */ new Error("next() called multiple times"));
+			index = i;
+			const fn = mws[i];
+			if (!fn) return finalNext ? finalNext() : Promise.resolve();
+			try {
+				return Promise.resolve(fn(input, () => dispatch(i + 1)));
+			} catch (err) {
+				return Promise.reject(err);
+			}
+		};
+		return dispatch(0);
+	};
+}
+
+//#endregion
+export { log_exports as n, Command as t };

package/dist/command.d.mts

@@ -0,0 +1,5 @@
+import "./color-BuHvMolk.mjs";
+import "./standard-schema-DLeKaehR.mjs";
+import "./input-B12iaqb8.mjs";
+import { a as ErrorFn, i as CommandAlias, n as Builder, o as MiddlewareFn, r as Command, s as ParseResult, t as ActionFn } from "./command-BXmfoT-l.mjs";
+export { ActionFn, Builder, Command, CommandAlias, ErrorFn, MiddlewareFn, ParseResult };

package/dist/command.mjs

@@ -0,0 +1,10 @@
+import "./utils-ChmY93uA.mjs";
+import "./color-OlJQTTxb.mjs";
+import "./error-C1S1gs8L.mjs";
+import "./standard-schema-DBXbMy6L.mjs";
+import "./raw--889icsd.mjs";
+import "./prompt-Cvufljin.mjs";
+import { t as Command } from "./command-D2UiQBNA.mjs";
+import "./input-DRy_sVxZ.mjs";
+
+export { Command };

package/dist/error-C1S1gs8L.mjs

@@ -0,0 +1,115 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
+
+//#region src/error.ts
+var error_exports = /* @__PURE__ */ __export({
+	ConvokerError: () => ConvokerError,
+	HelpAskedError: () => HelpAskedError,
+	InputValidationError: () => InputValidationError,
+	MissingRequiredArgumentError: () => MissingRequiredArgumentError,
+	MissingRequiredOptionError: () => MissingRequiredOptionError,
+	TooManyArgumentsError: () => TooManyArgumentsError,
+	UnknownOptionError: () => UnknownOptionError
+});
+/**
+* Thrown when the command fails to validate an input.
+*/
+var InputValidationError = class extends Error {
+	/**
+	* Creates a new input validation error.
+	* @param messages The messages.
+	*/
+	constructor(messages) {
+		super(`Validation failed: ${messages.join(", ")}`);
+		this.messages = messages;
+	}
+};
+/**
+* A Convoker-related error. These are usually handled by default.
+*/
+var ConvokerError = class extends Error {
+	/**
+	* Creates a new Convoker error.
+	* @param message The message.
+	* @param command The command.
+	*/
+	constructor(message, command) {
+		super(message);
+		this.command = command;
+	}
+	/**
+	* Prints the error's message.
+	*/
+	print() {
+		console.error(this.message);
+	}
+};
+/**
+* When the user asks for help.
+*/
+var HelpAskedError = class extends ConvokerError {
+	/**
+	* Creates a new help asked error.
+	* @param command The command.
+	*/
+	constructor(command) {
+		super("user asked for help!", command);
+	}
+};
+/**
+* When you pass too many arguments.
+*/
+var TooManyArgumentsError = class extends ConvokerError {
+	/**
+	* Creates a new too many arguments error.
+	* @param command The command.
+	*/
+	constructor(command) {
+		super("too many arguments!", command);
+	}
+};
+/**
+* When you pass an unknown option, when unknown options aren't allowed.
+*/
+var UnknownOptionError = class extends ConvokerError {
+	/**
+	* Creates a new unknown option error.
+	* @param command The command.
+	* @param key The key.
+	*/
+	constructor(command, key) {
+		super(`unknown option: ${key}!`, command);
+		this.key = key;
+	}
+};
+/**
+* When a required option is missing.
+*/
+var MissingRequiredOptionError = class extends ConvokerError {
+	/**
+	* Creates a new missing required option error.
+	* @param command The command.
+	* @param key The key.
+	* @param entry The entry.
+	*/
+	constructor(command, key, entry) {
+		super(`missing required option: ${key}!`, command);
+		this.key = key;
+		this.entry = entry;
+	}
+};
+var MissingRequiredArgumentError = class extends ConvokerError {
+	/**
+	* Creates a new missing required argument error.
+	* @param command The command.
+	* @param key The key.
+	* @param entry The entry.
+	*/
+	constructor(command, key, entry) {
+		super(`missing required positional argument: ${key}!`, command);
+		this.key = key;
+		this.entry = entry;
+	}
+};
+
+//#endregion
+export { MissingRequiredOptionError as a, error_exports as c, MissingRequiredArgumentError as i, HelpAskedError as n, TooManyArgumentsError as o, InputValidationError as r, UnknownOptionError as s, ConvokerError as t };