gunshi 0.2.0 → 0.2.2

package/lib/index.js

@@ -1,643 +1,8 @@
+import { COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, createCommandContext } from "./context-DmZAeiph.js";
+import { create, log, resolveLazyCommand } from "./utils-NHs5DuHk.js";
+import { renderHeader, renderUsage, renderValidationErrors } from "./renderer-Bo0DibAK.js";
+import { parseArgs, resolveArgs } from "args-tokens";
 
-//#region node_modules/.pnpm/args-tokens@0.10.2/node_modules/args-tokens/lib/parser.js
-const HYPHEN_CHAR = "-";
-const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
-const EQUAL_CHAR = "=";
-const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
-const TERMINATOR = "--";
-const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
-const LONG_OPTION_PREFIX = "--";
-function parseArgs(args, options = {}) {
-	const { allowCompatible = false } = options;
-	const tokens = [];
-	const remainings = [...args];
-	let index = -1;
-	let groupCount = 0;
-	let hasShortValueSeparator = false;
-	while (remainings.length > 0) {
-		const arg = remainings.shift();
-		if (arg == undefined) break;
-		const nextArg = remainings[0];
-		if (groupCount > 0) groupCount--;
-		else index++;
-		if (arg === TERMINATOR) {
-			tokens.push({
-				kind: "option-terminator",
-				index
-			});
-			const mapped = remainings.map((arg$1) => {
-				return {
-					kind: "positional",
-					index: ++index,
-					value: arg$1
-				};
-			});
-			tokens.push(...mapped);
-			break;
-		}
-		if (isShortOption(arg)) {
-			const shortOption = arg.charAt(1);
-			let value;
-			let inlineValue;
-			if (groupCount) {
-				tokens.push({
-					kind: "option",
-					name: shortOption,
-					rawName: arg,
-					index,
-					value,
-					inlineValue
-				});
-				if (groupCount === 1 && hasOptionValue(nextArg)) {
-					value = remainings.shift();
-					if (hasShortValueSeparator) {
-						inlineValue = true;
-						hasShortValueSeparator = false;
-					}
-					tokens.push({
-						kind: "option",
-						index,
-						value,
-						inlineValue
-					});
-				}
-			} else tokens.push({
-				kind: "option",
-				name: shortOption,
-				rawName: arg,
-				index,
-				value,
-				inlineValue
-			});
-			if (value != null) ++index;
-			continue;
-		}
-		if (isShortOptionGroup(arg)) {
-			const expanded = [];
-			let shortValue = "";
-			for (let i = 1; i < arg.length; i++) {
-				const shortableOption = arg.charAt(i);
-				if (hasShortValueSeparator) shortValue += shortableOption;
-				else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE) hasShortValueSeparator = true;
-				else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
-			}
-			if (shortValue) expanded.push(shortValue);
-			remainings.unshift(...expanded);
-			groupCount = expanded.length;
-			continue;
-		}
-		if (isLongOption(arg)) {
-			const longOption = arg.slice(2);
-			tokens.push({
-				kind: "option",
-				name: longOption,
-				rawName: arg,
-				index,
-				value: undefined,
-				inlineValue: undefined
-			});
-			continue;
-		}
-		if (isLongOptionAndValue(arg)) {
-			const equalIndex = arg.indexOf(EQUAL_CHAR);
-			const longOption = arg.slice(2, equalIndex);
-			const value = arg.slice(equalIndex + 1);
-			tokens.push({
-				kind: "option",
-				name: longOption,
-				rawName: `${LONG_OPTION_PREFIX}${longOption}`,
-				index,
-				value,
-				inlineValue: true
-			});
-			continue;
-		}
-		tokens.push({
-			kind: "positional",
-			index,
-			value: arg
-		});
-	}
-	return tokens;
-}
-function isShortOption(arg) {
-	return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
-}
-/**
-* Check if `arg` is a short option group (e.g. `-abc`)
-* @param arg the argument to check
-* @returns whether `arg` is a short option group
-*/
-function isShortOptionGroup(arg) {
-	if (arg.length <= 2) return false;
-	if (arg.codePointAt(0) !== HYPHEN_CODE) return false;
-	if (arg.codePointAt(1) === HYPHEN_CODE) return false;
-	return true;
-}
-/**
-* Check if `arg` is a long option (e.g. `--foo`)
-* @param arg the argument to check
-* @returns whether `arg` is a long option
-*/
-function isLongOption(arg) {
-	return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
-}
-/**
-* Check if `arg` is a long option with value (e.g. `--foo=bar`)
-* @param arg the argument to check
-* @returns whether `arg` is a long option
-*/
-function isLongOptionAndValue(arg) {
-	return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
-}
-function hasLongOptionPrefix(arg) {
-	return arg.length > 2 && ~arg.indexOf(LONG_OPTION_PREFIX);
-}
-/**
-* Check if a `value` is an option value
-* @param value a value to check
-* @returns whether a `value` is an option value
-*/
-function hasOptionValue(value) {
-	return !(value == null) && value.codePointAt(0) !== HYPHEN_CODE;
-}
-
-//#endregion
-//#region node_modules/.pnpm/args-tokens@0.10.2/node_modules/args-tokens/lib/resolver.js
-function resolveArgs(options, tokens) {
-	const positionals = [];
-	const longOptionTokens = [];
-	const shortOptionTokens = [];
-	let currentLongOption;
-	let currentShortOption;
-	const expandableShortOptions = [];
-	function toShortValue() {
-		if (expandableShortOptions.length === 0) return undefined;
-		else {
-			const value = expandableShortOptions.map((token) => token.name).join("");
-			expandableShortOptions.length = 0;
-			return value;
-		}
-	}
-	function applyLongOptionValue(value = undefined) {
-		if (currentLongOption) {
-			currentLongOption.value = value;
-			longOptionTokens.push({ ...currentLongOption });
-			currentLongOption = undefined;
-		}
-	}
-	function applyShortOptionValue(value = undefined) {
-		if (currentShortOption) {
-			currentShortOption.value = value || toShortValue();
-			shortOptionTokens.push({ ...currentShortOption });
-			currentShortOption = undefined;
-		}
-	}
-	/**
-	* analyze phase to resolve value
-	* separate tokens into positionals, long and short options, after that resolve values
-	*/
-	for (let i = 0; i < tokens.length; i++) {
-		const token = tokens[i];
-		if (token.kind === "positional") {
-			positionals.push(token.value);
-			applyLongOptionValue(token.value);
-			applyShortOptionValue(token.value);
-		} else if (token.kind === "option") if (token.rawName) {
-			if (hasLongOptionPrefix(token.rawName)) {
-				if (token.inlineValue) longOptionTokens.push({ ...token });
-				else currentLongOption = { ...token };
-				applyShortOptionValue();
-			} else if (isShortOption(token.rawName)) if (currentShortOption) {
-				if (currentShortOption.index === token.index) expandableShortOptions.push({ ...token });
-				else {
-					currentShortOption.value = toShortValue();
-					shortOptionTokens.push({ ...currentShortOption });
-					currentShortOption = { ...token };
-				}
-				applyLongOptionValue();
-			} else {
-				currentShortOption = { ...token };
-				applyLongOptionValue();
-			}
-		} else {
-			if (currentShortOption && currentShortOption.index == token.index && token.inlineValue) {
-				currentShortOption.value = token.value;
-				shortOptionTokens.push({ ...currentShortOption });
-				currentShortOption = undefined;
-			}
-			applyLongOptionValue();
-		}
-		else {
-			applyLongOptionValue();
-			applyShortOptionValue();
-		}
-	}
-	/**
-	* check if the last long or short option is not resolved
-	*/
-	applyLongOptionValue();
-	applyShortOptionValue();
-	/**
-	* resolve values
-	*/
-	const values = Object.create(null);
-	const errors = [];
-	for (const [option, schema] of Object.entries(options)) {
-		if (schema.required) {
-			const found = longOptionTokens.find((token) => token.name === option) || schema.short && shortOptionTokens.find((token) => token.name === schema.short);
-			if (!found) {
-				errors.push(createRequireError(option, schema));
-				continue;
-			}
-		}
-		for (let i = 0; i < longOptionTokens.length; i++) {
-			const token = longOptionTokens[i];
-			if (option === token.name && token.rawName != null && hasLongOptionPrefix(token.rawName)) {
-				const invalid = validateRequire(token, option, schema);
-				if (invalid) {
-					errors.push(invalid);
-					continue;
-				}
-				if (schema.type === "boolean") token.value = undefined;
-				else {
-					const invalid$1 = validateValue(token, option, schema);
-					if (invalid$1) {
-						errors.push(invalid$1);
-						continue;
-					}
-				}
-				values[option] = resolveOptionValue(token, schema);
-				continue;
-			}
-		}
-		for (let i = 0; i < shortOptionTokens.length; i++) {
-			const token = shortOptionTokens[i];
-			if (schema.short === token.name && token.rawName != null && isShortOption(token.rawName)) {
-				const invalid = validateRequire(token, option, schema);
-				if (invalid) {
-					errors.push(invalid);
-					continue;
-				}
-				if (schema.type === "boolean") token.value = undefined;
-				else {
-					const invalid$1 = validateValue(token, option, schema);
-					if (invalid$1) {
-						errors.push(invalid$1);
-						continue;
-					}
-				}
-				values[option] = resolveOptionValue(token, schema);
-				continue;
-			}
-		}
-		if (values[option] == null && schema.default != null) values[option] = schema.default;
-	}
-	return {
-		values,
-		positionals,
-		error: errors.length > 0 ? new AggregateError(errors) : undefined
-	};
-}
-function createRequireError(option, schema) {
-	return new Error(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}is required`);
-}
-function validateRequire(token, option, schema) {
-	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(option, schema);
-}
-function validateValue(token, option, schema) {
-	switch (schema.type) {
-		case "number": {
-			if (!isNumeric(token.value)) return createTypeError(option, schema);
-			break;
-		}
-		case "string": {
-			if (typeof token.value !== "string") return createTypeError(option, schema);
-			break;
-		}
-	}
-}
-function isNumeric(str) {
-	return str.trim() !== "" && !isNaN(str);
-}
-function createTypeError(option, schema) {
-	return new TypeError(`Option '--${option}' ${schema.short ? `or '-${schema.short}' ` : ""}should be '${schema.type}'`);
-}
-function resolveOptionValue(token, schema) {
-	if (token.value) return schema.type === "number" ? +token.value : token.value;
-	if (schema.type === "boolean") return true;
-	return schema.type === "number" ? +(schema.default || "") : schema.default;
-}
-
-//#endregion
-//#region src/constants.ts
-const COMMON_OPTIONS = {
-	help: {
-		type: "boolean",
-		short: "h"
-	},
-	version: {
-		type: "boolean",
-		short: "v"
-	}
-};
-const COMMAND_OPTIONS_DEFAULT = {
-	name: undefined,
-	description: undefined,
-	version: undefined,
-	cwd: undefined,
-	subCommands: undefined,
-	leftMargin: 2,
-	middleMargin: 10,
-	usageOptionType: false,
-	renderHeader: undefined,
-	renderUsage: undefined,
-	renderValidationErrors: undefined
-};
-const COMMAND_I18N_RESOURCE_KEYS = [
-	"USAGE",
-	"COMMAND",
-	"SUBCOMMAND",
-	"COMMANDS",
-	"OPTIONS",
-	"EXAMPLES",
-	"FORMORE"
-];
-
-//#endregion
-//#region locales/en-US.json
-var COMMAND = "COMMAND";
-var COMMANDS = "COMMANDS";
-var SUBCOMMAND = "SUBCOMMAND";
-var USAGE = "USAGE";
-var OPTIONS = "OPTIONS";
-var EXAMPLES = "EXAMPLES";
-var FORMORE = "For more info, run any command with the `--help` flag:";
-var help = "Display this help message";
-var version = "Display this version";
-var en_US_default = {
-	COMMAND,
-	COMMANDS,
-	SUBCOMMAND,
-	USAGE,
-	OPTIONS,
-	EXAMPLES,
-	FORMORE,
-	help,
-	version
-};
-
-//#endregion
-//#region src/utils.ts
-async function resolveLazyCommand(cmd, name, entry = false) {
-	const resolved = Object.assign(create(), typeof cmd == "function" ? await cmd() : cmd, { default: entry });
-	if (resolved.name == null && name) resolved.name = name;
-	return deepFreeze(resolved);
-}
-function create(obj = null) {
-	return Object.create(obj);
-}
-function log(...args) {
-	console.log(...args);
-}
-function deepFreeze(obj) {
-	if (obj === null || typeof obj !== "object") return obj;
-	for (const key of Object.keys(obj)) {
-		const value = obj[key];
-		if (typeof value === "object" && value !== null) deepFreeze(value);
-	}
-	return Object.freeze(obj);
-}
-
-//#endregion
-//#region src/context.ts
-const DEFAULT_LOCALE = "en-US";
-async function createCommandContext({ options, values, positionals, command, commandOptions, omitted = false }) {
-	/**
-	* tweak the options and values
-	*/
-	const _options = options == null ? undefined : Object.entries(options).reduce((acc, [key, value]) => {
-		acc[key] = Object.assign(create(), value);
-		return acc;
-	}, create());
-	const _values = Object.assign(create(), values);
-	/**
-	* normalize the usage
-	*/
-	const usage = Object.assign(create(), command.usage);
-	const { help: help$1, version: version$1 } = en_US_default;
-	usage.options = Object.assign(create(), usage.options, {
-		help: help$1,
-		version: version$1
-	});
-	/**
-	* setup the environment
-	*/
-	const env = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, commandOptions);
-	const locale = resolveLocale(commandOptions.locale);
-	const localeResources = new Map();
-	const commandResources = new Map();
-	let builtInLoadedResources;
-	/**
-	* load the built-in locale resources
-	*/
-	localeResources.set(DEFAULT_LOCALE, en_US_default);
-	if (DEFAULT_LOCALE !== locale.toString()) try {
-		builtInLoadedResources = await import(`../locales/${locale.toString()}.json`, { with: { type: "json" } });
-		localeResources.set(locale.toString(), builtInLoadedResources);
-	} catch {}
-	/**
-	* define the translation function
-	*/
-	function translation(key) {
-		if (COMMAND_I18N_RESOURCE_KEYS.includes(key)) {
-			const resource = localeResources.get(locale.toString()) || localeResources.get(DEFAULT_LOCALE);
-			return resource[key] || key;
-		} else {
-			const resource = commandResources.get(locale.toString()) || commandResources.get(DEFAULT_LOCALE);
-			return resource[key] || "";
-		}
-	}
-	/**
-	* load the sub commands
-	*/
-	let cachedCommands;
-	async function loadCommands() {
-		if (cachedCommands) return cachedCommands;
-		const subCommands = [...env.subCommands || []];
-		return cachedCommands = await Promise.all(subCommands.map(async ([name, cmd]) => await resolveLazyCommand(cmd, name)));
-	}
-	/**
-	* create the context
-	*/
-	const ctx = deepFreeze(Object.assign(create(), {
-		name: command.name,
-		description: command.description,
-		omitted,
-		locale,
-		env,
-		options: _options,
-		values: _values,
-		positionals,
-		usage,
-		loadCommands,
-		translation
-	}));
-	/**
-	* load the command resources
-	*/
-	const loadedOptionsResources = Object.entries(usage.options || create()).map(([key, _]) => {
-		const option = usage.options[key];
-		return [key, option];
-	});
-	const defaultCommandResource = loadedOptionsResources.reduce((res, [key, value]) => {
-		res[key] = value;
-		return res;
-	}, create());
-	defaultCommandResource.description = command.description || "";
-	defaultCommandResource.examples = usage.examples || "";
-	commandResources.set(DEFAULT_LOCALE, defaultCommandResource);
-	const originalResource = await loadCommandResource(ctx, command);
-	if (originalResource) {
-		const resource = Object.entries(originalResource.options).reduce((res, [key, value]) => {
-			res[key] = value;
-			return res;
-		}, Object.assign(create(), {
-			description: originalResource.description,
-			examples: originalResource.examples
-		}));
-		if (builtInLoadedResources) {
-			resource.help = builtInLoadedResources.help;
-			resource.version = builtInLoadedResources.version;
-		}
-		commandResources.set(locale.toString(), resource);
-	}
-	return ctx;
-}
-function resolveLocale(locale) {
-	return locale instanceof Intl.Locale ? locale : typeof locale === "string" ? new Intl.Locale(locale) : new Intl.Locale(DEFAULT_LOCALE);
-}
-async function loadCommandResource(ctx, command) {
-	let resource;
-	try {
-		resource = await command.resource?.(ctx);
-	} catch {}
-	return resource;
-}
-
-//#endregion
-//#region src/renderer.ts
-function renderHeader(ctx) {
-	const title = ctx.env.description || ctx.env.name || "";
-	return Promise.resolve(title ? `${title} (${ctx.env.name || ""}${ctx.env.version ? ` v${ctx.env.version}` : ""})` : title);
-}
-async function renderUsage(ctx) {
-	const messages = [];
-	if (!ctx.omitted && hasDescription(ctx)) messages.push(ctx.description, "");
-	messages.push(...await renderUsageSection(ctx), "");
-	if (ctx.omitted && await hasCommands(ctx)) messages.push(...await renderCommandsSection(ctx), "");
-	if (hasOptions(ctx)) messages.push(...await renderOptionsSection(ctx), "");
-	if (hasExamples(ctx)) messages.push(...renderExamplesSection(ctx), "");
-	return messages.join("\n");
-}
-function renderValidationErrors(_ctx, error) {
-	const messages = [];
-	for (const err of error.errors) messages.push(err.message);
-	return Promise.resolve(messages.join("\n"));
-}
-async function renderOptionsSection(ctx) {
-	const messages = [];
-	messages.push(`${ctx.translation("OPTIONS")}:`);
-	const optionsPairs = getOptionsPairs(ctx);
-	messages.push(await generateOptionsUsage(ctx, optionsPairs));
-	return messages;
-}
-function renderExamplesSection(ctx) {
-	const messages = [];
-	const examples = ctx.usage.examples.split("\n").map((example) => example.padStart(ctx.env.leftMargin + example.length));
-	messages.push(`${ctx.translation("EXAMPLES")}:`, ...examples);
-	return messages;
-}
-async function renderUsageSection(ctx) {
-	const messages = [`${ctx.translation("USAGE")}:`];
-	if (ctx.omitted) {
-		const defaultCommand = `${resolveEntry(ctx)}${await hasCommands(ctx) ? ` [${resolveSubCommand(ctx)}]` : ""} ${hasOptions(ctx) ? `<${ctx.translation("OPTIONS")}>` : ""} `;
-		messages.push(defaultCommand.padStart(ctx.env.leftMargin + defaultCommand.length));
-		if (await hasCommands(ctx)) {
-			const commandsUsage = `${resolveEntry(ctx)} <${ctx.translation("COMMANDS")}>`;
-			messages.push(commandsUsage.padStart(ctx.env.leftMargin + commandsUsage.length));
-		}
-	} else {
-		const usageStr = `${resolveEntry(ctx)} ${resolveSubCommand(ctx)} ${generateOptionsSymbols(ctx)}`;
-		messages.push(usageStr.padStart(ctx.env.leftMargin + usageStr.length));
-	}
-	return messages;
-}
-async function renderCommandsSection(ctx) {
-	const messages = [`${ctx.translation("COMMANDS")}:`];
-	const loadedCommands = await ctx.loadCommands();
-	const commandMaxLength = Math.max(...loadedCommands.map((cmd) => (cmd.name || "").length));
-	const commandsStr = await Promise.all(loadedCommands.map((cmd) => {
-		const key = cmd.name || "";
-		const desc = cmd.description || "";
-		const command = `${key.padEnd(commandMaxLength + ctx.env.middleMargin)}${desc} `;
-		return `${command.padStart(ctx.env.leftMargin + command.length)} `;
-	}));
-	messages.push(...commandsStr, "", ctx.translation("FORMORE"));
-	messages.push(...loadedCommands.map((cmd) => {
-		const commandHelp = `${ctx.env.name} ${cmd.name} --help`;
-		return `${commandHelp.padStart(ctx.env.leftMargin + commandHelp.length)}`;
-	}));
-	return messages;
-}
-function resolveEntry(ctx) {
-	return ctx.env.name || ctx.translation("COMMAND");
-}
-function resolveSubCommand(ctx) {
-	return ctx.name || ctx.translation("SUBCOMMAND");
-}
-function hasDescription(ctx) {
-	return !!ctx.description;
-}
-async function hasCommands(ctx) {
-	const loadedCommands = await ctx.loadCommands();
-	return loadedCommands.length > 1;
-}
-function hasOptions(ctx) {
-	return !!(ctx.options && Object.keys(ctx.options).length > 0);
-}
-function hasExamples(ctx) {
-	return !!ctx.usage.examples;
-}
-function hasAllDefaultOptions(ctx) {
-	return !!(ctx.options && Object.values(ctx.options).every((opt) => opt.default));
-}
-function generateOptionsSymbols(ctx) {
-	return hasOptions(ctx) ? hasAllDefaultOptions(ctx) ? `[${ctx.translation("OPTIONS")}]` : `<${ctx.translation("OPTIONS")}>` : "";
-}
-function getOptionsPairs(ctx) {
-	return Object.entries(ctx.options).reduce((acc, [name, value]) => {
-		let key = `--${name}`;
-		if (value.short) key = `-${value.short}, ${key}`;
-		if (value.type !== "boolean") key = value.default ? `${key} [${name}]` : `${key} <${name}>`;
-		acc[name] = key;
-		return acc;
-	}, create());
-}
-async function generateOptionsUsage(ctx, optionsPairs) {
-	const optionsMaxLength = Math.max(...Object.entries(optionsPairs).map(([_, value]) => value.length));
-	const optionSchemaMaxLength = ctx.env.usageOptionType ? Math.max(...Object.entries(optionsPairs).map(([key, _]) => ctx.options[key].type.length)) : 0;
-	const usages = await Promise.all(Object.entries(optionsPairs).map(([key, value]) => {
-		const rawDesc = ctx.translation(key);
-		const optionsSchema = ctx.env.usageOptionType ? `[${ctx.options[key].type}] ` : "";
-		const desc = `${optionsSchema ? optionsSchema.padEnd(optionSchemaMaxLength + 3) : ""}${rawDesc}`;
-		const option = `${value.padEnd(optionsMaxLength + ctx.env.middleMargin)}${desc}`;
-		return `${option.padStart(ctx.env.leftMargin + option.length)}`;
-	}));
-	return usages.join("\n");
-}
-
-//#endregion
 //#region src/cli.ts
 async function cli(args, entry, opts = {}) {
 	const tokens = parseArgs(args);
@@ -668,7 +33,7 @@ async function cli(args, entry, opts = {}) {
 	}
 	if (error) {
 		await showValidationErrors(ctx, error);
-		throw error;
+		return;
 	}
 	await command.run(ctx);
 }