gunshi 0.2.0 → 0.2.2

package/lib/context-DmZAeiph.js

@@ -0,0 +1,178 @@
+import { create, deepFreeze, resolveLazyCommand } from "./utils-NHs5DuHk.js";
+
+//#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/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 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, which is used to {@link CommandContext.translation}.
+	*
+	*/
+	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
+export { COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, DEFAULT_LOCALE, createCommandContext };

package/lib/context.d.ts

@@ -1,14 +1,50 @@
-import type { ArgOptions, ArgValues } from "args-tokens";
-import type { Command, CommandContext, CommandOptions } from "./types.js";
-export declare const DEFAULT_LOCALE = "en-US";
-export declare function createCommandContext<
+import { ArgOptions, ArgValues } from 'args-tokens';
+import { C as Command, a as CommandOptions, b as CommandContext } from './types.d-00BVt8hZ.js';
+
+/**
+* The default locale string, which format is BCP 47 language tag
+*/
+declare const DEFAULT_LOCALE = "en-US";
+/**
+* Parameters of {@link createCommandContext}
+*/
+interface CommandContextParams<
+	Options extends ArgOptions,
+	Values
+> {
+	/**
+	* An options of target command
+	*/
+	options: Options | undefined;
+	/**
+	* A values of target command
+	*/
+	values: Values;
+	/**
+	* A positionals arguments, which passed to the target command
+	*/
+	positionals: string[];
+	/**
+	* Whether the command is omitted
+	*/
+	omitted: boolean;
+	/**
+	* A target {@link Command | command}
+	*/
+	command: Command<Options>;
+	/**
+	* A command options, which is spicialized from `cli` function
+	*/
+	commandOptions: CommandOptions<Options>;
+}
+/**
+* Create a {@link CommandContext | command context}
+* @param param A {@link CommandContextParams | parameters} to create a {@link CommandContext | command context}
+* @returns A {@link CommandContext | command context}, which is readonly
+*/
+declare function createCommandContext<
 	Options extends ArgOptions,
 	Values = ArgValues<Options>
->({ options, values, positionals, command, commandOptions, omitted }: {
-	options: Options | undefined
-	values: Values
-	positionals: string[]
-	omitted: boolean
-	command: Command<Options>
-	commandOptions: CommandOptions<Options>
-}): Promise<Readonly<CommandContext<Options, Values>>>;
+>({ options, values, positionals, command, commandOptions, omitted }: CommandContextParams<Options, Values>): Promise<Readonly<CommandContext<Options, Values>>>;
+
+export { DEFAULT_LOCALE, createCommandContext };

package/lib/context.js

@@ -0,0 +1,4 @@
+import { DEFAULT_LOCALE, createCommandContext } from "./context-DmZAeiph.js";
+import "./utils-NHs5DuHk.js";
+
+export { DEFAULT_LOCALE, createCommandContext };

package/lib/index.d.ts

@@ -1,2 +1,14 @@
-export * from "./cli.js";
-export type * from "./types.js";
+import { ArgOptions } from 'args-tokens';
+export { ArgOptionSchema, ArgOptions, ArgValues } from 'args-tokens';
+import { C as Command, c as CommandRunner, a as CommandOptions } from './types.d-00BVt8hZ.js';
+export { f as CommandBuiltinKeys, d as CommandBuiltinOptionsKeys, e as CommandBuiltinResourceKeys, b as CommandContext, g as CommandEnvironment, h as CommandResource, i as CommandResourceFetcher, L as LazyCommand } from './types.d-00BVt8hZ.js';
+
+/**
+* Run the command
+* @param args - command line arguments
+* @param entry - A {@link Command | entry command} or an {@link CommandRunner | inline command runner}
+* @param opts - A {@link CommandOptions | command options}
+*/
+declare function cli<Options extends ArgOptions>(args: string[], entry: Command<Options> | CommandRunner<Options>, opts?: CommandOptions<Options>): Promise<void>;
+
+export { Command, CommandOptions, CommandRunner, cli };