@gunshi/plugin-renderer 0.26.3 → 0.27.0-alpha.10

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { Command, CommandContext, DefaultGunshiParams, GunshiParams, PluginWithExtension } from "@gunshi/plugin";
-import { Args } from "args-tokens";
+import { Args, Command, CommandContext, DefaultGunshiParams, GunshiParams, PluginWithExtension } from "@gunshi/plugin";
+import { Args as Args$1 } from "args-tokens";
 
 //#region rolldown:runtime
 declare namespace constants_d_exports {
@@ -30,7 +30,6 @@ type CommonArgType = {
 };
 declare const COMMON_ARGS: CommonArgType;
 declare const COMMAND_BUILTIN_RESOURCE_KEYS: readonly ["USAGE", "COMMAND", "SUBCOMMAND", "COMMANDS", "ARGUMENTS", "OPTIONS", "EXAMPLES", "FORMORE", "NEGATABLE", "DEFAULT", "CHOICES"];
-
 //#endregion
 //#region ../shared/src/types.d.ts
 type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
@@ -38,7 +37,7 @@ type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : num
  * Remove index signature from object or record type.
  */
 type RemovedIndex<T> = RemoveIndexSignature<{ [K in keyof T]: T[K] }>;
-type KeyOfArgs<A extends Args> = keyof A | { [K in keyof A]: A[K]['type'] extends 'boolean' ? A[K]['negatable'] extends true ? `no-${Extract<K, string>}` : never : never }[keyof A];
+type KeyOfArgs<A extends Args$1> = keyof A | { [K in keyof A]: A[K]['type'] extends 'boolean' ? A[K]['negatable'] extends true ? `no-${Extract<K, string>}` : never : never }[keyof A];
 /**
  * Generate a namespaced key.
  */
@@ -52,20 +51,33 @@ type CommandBuiltinArgsKeys = keyof (typeof constants_d_exports)['COMMON_ARGS'];
  */
 type CommandBuiltinResourceKeys = (typeof constants_d_exports)['COMMAND_BUILTIN_RESOURCE_KEYS'][number];
 /**
- * i18n built-in resource keys.
+ * Built-in resource keys.
  */
 type BuiltinResourceKeys = CommandBuiltinArgsKeys | CommandBuiltinResourceKeys;
 /**
- * Command i18n built-in keys.
- * The command i18n built-in keys are used by the i18n plugin for translation.
+ * Command built-in keys.
  */
-type CommandBuiltinKeys = GenerateNamespacedKey<BuiltinResourceKeys> | 'description' | 'examples';
+type CommandBuiltinKeys = GenerateNamespacedKey<BuiltinResourceKeys>;
 /**
  * Command i18n option keys.
  * The command i18n option keys are used by the i18n plugin for translation.
  */
-type CommandArgKeys<A extends Args> = GenerateNamespacedKey<KeyOfArgs<RemovedIndex<A>>, typeof ARG_PREFIX>;
-
+type CommandArgKeys<A extends Args$1, C = {}, K extends string = GenerateNamespacedKey<Extract<KeyOfArgs<RemovedIndex<A>>, string>, typeof ARG_PREFIX>> = C extends {
+  name: infer N;
+} ? (N extends string ? GenerateNamespacedKey<K, N> : K) : K;
+/**
+ * Resolve translation keys for command context.
+ */
+type ResolveTranslationKeys<A extends Args$1, C = {},
+// for CommandContext
+E extends Record<string, string> = {},
+// for extended resources
+R extends string = keyof RemovedIndex<E>, T extends string = (C extends {
+  name: infer N;
+} ? N extends string ? GenerateNamespacedKey<R, N> : R : R | CommandBuiltinKeys), O = CommandArgKeys<A, C>> = CommandBuiltinKeys | O | T;
+/**
+ * Translation function interface
+ */
 //#endregion
 //#region src/types.d.ts
 /**
@@ -76,14 +88,17 @@ interface UsageRendererCommandContext<G extends GunshiParams<any> = DefaultGunsh
   /**
    * Render the text message
    */
-  text: <T extends string = CommandBuiltinKeys, O = CommandArgKeys<G['args']>, K = CommandBuiltinKeys | O | T>(key: K, values?: Record<string, unknown>) => Promise<string>;
+  text: <A extends Args = G['args'], C = {},
+  // for CommandContext
+  E extends Record<string, string> = {},
+  // for extended resources
+  K = ResolveTranslationKeys<A, C, E>>(key: K, values?: Record<string, unknown>) => string;
   /**
    * Load commands
-   * @returns A list of commands loaded from the command loader plugin.
+   * @returns A list of commands loaded from the usage renderert plugin.
    */
   loadCommands: <G extends GunshiParams = DefaultGunshiParams>() => Promise<Command<G>[]>;
 }
-
 //#endregion
 //#region src/header.d.ts
 /**
@@ -92,7 +107,6 @@ interface UsageRendererCommandContext<G extends GunshiParams<any> = DefaultGunsh
  * @returns A rendered header.
  */
 declare function renderHeader<G extends GunshiParams = DefaultGunshiParams>(ctx: Readonly<CommandContext<G>>): Promise<string>;
-
 //#endregion
 //#region src/usage.d.ts
 /**
@@ -101,7 +115,6 @@ declare function renderHeader<G extends GunshiParams = DefaultGunshiParams>(ctx:
  * @returns A rendered usage.
  */
 declare function renderUsage<G extends GunshiParams = DefaultGunshiParams>(ctx: Readonly<CommandContext<G>>): Promise<string>;
-
 //#endregion
 //#region src/validation.d.ts
 /**
@@ -111,13 +124,11 @@ declare function renderUsage<G extends GunshiParams = DefaultGunshiParams>(ctx:
  * @returns A rendered validation error.
  */
 declare function renderValidationErrors<G extends GunshiParams = DefaultGunshiParams>(_ctx: CommandContext<G>, error: AggregateError): Promise<string>;
-
 //#endregion
 //#region src/index.d.ts
 /**
  * usage renderer plugin
  */
 declare function renderer(): PluginWithExtension<UsageRendererCommandContext>;
-
 //#endregion
-export { UsageRendererCommandContext, renderer as default, renderHeader, renderUsage, renderValidationErrors };
+export { type UsageRendererCommandContext, renderer as default, renderHeader, renderUsage, renderValidationErrors };

package/lib/index.js

@@ -1,6 +1,6 @@
-import { plugin } from "@gunshi/plugin";
+import { ANONYMOUS_COMMAND_NAME, plugin } from "@gunshi/plugin";
 
-//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/utils-N7UlhLbz.js
+//#region ../../node_modules/.pnpm/args-tokens@0.22.0/node_modules/args-tokens/lib/utils-N7UlhLbz.js
 /**
 * Entry point of utils.
 *
@@ -28,7 +28,9 @@ async function resolveLazyCommand(cmd, name, needRunResolving = false) {
 			name: cmd.commandName,
 			description: cmd.description,
 			args: cmd.args,
-			examples: cmd.examples
+			examples: cmd.examples,
+			internal: cmd.internal,
+			entry: cmd.entry
 		};
 		if ("resource" in cmd && cmd.resource) baseCommand.resource = cmd.resource;
 		command = Object.assign(create(), baseCommand);
@@ -42,6 +44,8 @@ async function resolveLazyCommand(cmd, name, needRunResolving = false) {
 				command.description = loaded.description;
 				command.args = loaded.args;
 				command.examples = loaded.examples;
+				command.internal = loaded.internal;
+				command.entry = loaded.entry;
 				if ("resource" in loaded && loaded.resource) command.resource = loaded.resource;
 			} else throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
 		}
@@ -121,11 +125,35 @@ var en_US_default = {
 
 //#endregion
 //#region ../shared/src/utils.ts
+/**
+* Resolve a namespaced key for built-in resources.
+* Built-in keys are prefixed with "_:".
+* @param key The built-in key to resolve.
+* @returns Prefixed built-in key.
+*/
 function resolveBuiltInKey(key) {
 	return `${BUILT_IN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
 }
-function resolveArgKey(key) {
-	return `${ARG_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+/**
+* Resolve a namespaced key for argument resources.
+* Argument keys are prefixed with "arg:".
+* If the command name is provided, it will be prefixed with the command name (e.g. "cmd1:arg:foo").
+* @param key The argument key to resolve.
+* @param ctx The command context.
+* @returns Prefixed argument key.
+*/
+function resolveArgKey(key, ctx) {
+	return `${ctx?.name ? `${ctx.name}${BUILT_IN_KEY_SEPARATOR}` : ""}${ARG_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
+/**
+* Resolve a namespaced key for non-built-in resources.
+* Non-built-in keys are not prefixed with any special characters. If the command name is provided, it will be prefixed with the command name (e.g. "cmd1:foo").
+* @param key The non-built-in key to resolve.
+* @param ctx The command context.
+* @returns Prefixed non-built-in key.
+*/
+function resolveKey(key, ctx) {
+	return `${ctx?.name ? `${ctx.name}${BUILT_IN_KEY_SEPARATOR}` : ""}${key}`;
 }
 async function resolveExamples$1(ctx, examples) {
 	return typeof examples === "string" ? examples : typeof examples === "function" ? await examples(ctx) : "";
@@ -133,6 +161,48 @@ async function resolveExamples$1(ctx, examples) {
 function namespacedId(id) {
 	return `${PLUGIN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${id}`;
 }
+function makeShortLongOptionPair(schema, name, toKebab) {
+	const displayName = toKebab || schema.toKebab ? kebabnize(name) : name;
+	let key = `--${displayName}`;
+	if (schema.short) key = `-${schema.short}, ${key}`;
+	return key;
+}
+
+//#endregion
+//#region ../shared/src/localization.ts
+/**
+* Create a localizable function for a command.
+* This function will resolve the translation key based on the command context and the provided translation function.
+* @param ctx Command context
+* @param cmd Command
+* @param translate Translation function
+* @returns Localizable function
+*/
+function localizable(ctx, cmd, translate) {
+	async function localize(key, values) {
+		if (translate) return translate(key, values);
+		if (key.startsWith(BUILD_IN_PREFIX_AND_KEY_SEPARATOR)) {
+			const resKey = key.slice(BUILD_IN_PREFIX_AND_KEY_SEPARATOR.length);
+			return en_US_default[resKey] || key;
+		}
+		const namaspacedArgKey = resolveKey(ARG_PREFIX_AND_KEY_SEPARATOR, ctx);
+		if (key.startsWith(namaspacedArgKey)) {
+			let argKey = key.slice(namaspacedArgKey.length);
+			let negatable = false;
+			if (argKey.startsWith(ARG_NEGATABLE_PREFIX)) {
+				argKey = argKey.slice(ARG_NEGATABLE_PREFIX.length);
+				negatable = true;
+			}
+			const schema = ctx.args[argKey];
+			if (!schema) return argKey;
+			return negatable && schema.type === "boolean" && schema.negatable ? `${en_US_default["NEGATABLE"]} ${makeShortLongOptionPair(schema, argKey, ctx.toKebab)}` : schema.description || "";
+		}
+		if (key === resolveKey("description", ctx)) return "";
+		else if (key === resolveKey("examples", ctx)) return await resolveExamples$1(ctx, cmd.examples);
+		else return key;
+	}
+	return localize;
+}
 
 //#endregion
 //#region src/header.ts
@@ -169,8 +239,8 @@ async function renderUsage(ctx) {
 	}
 	messages.push(...await renderUsageSection(ctx), "");
 	if (ctx.omitted && await hasCommands(ctx)) messages.push(...await renderCommandsSection(ctx), "");
-	if (hasPositionalArgs(ctx)) messages.push(...await renderPositionalArgsSection(ctx), "");
-	if (hasOptionalArgs(ctx)) messages.push(...await renderOptionalArgsSection(ctx), "");
+	if (hasPositionalArgs(ctx.args)) messages.push(...await renderPositionalArgsSection(ctx), "");
+	if (hasOptionalArgs(ctx.args)) messages.push(...await renderOptionalArgsSection(ctx), "");
 	const examples = await renderExamplesSection(ctx);
 	if (examples.length > 0) messages.push(...examples, "");
 	return messages.join("\n");
@@ -218,19 +288,21 @@ async function renderExamplesSection(ctx) {
 */
 async function renderUsageSection(ctx) {
 	const messages = [`${await ctx.extensions[pluginId].text(resolveBuiltInKey("USAGE"))}:`];
-	if (ctx.omitted) {
-		const defaultCommand = `${await resolveEntry(ctx)}${await hasCommands(ctx) ? ` [${await resolveSubCommand(ctx)}]` : ""} ${[await generateOptionsSymbols(ctx), generatePositionalSymbols(ctx)].filter(Boolean).join(" ")}`;
-		messages.push(defaultCommand.padStart(ctx.env.leftMargin + defaultCommand.length));
-		if (await hasCommands(ctx)) {
-			const commandsUsage = `${await resolveEntry(ctx)} <${await ctx.extensions[pluginId].text(resolveBuiltInKey("COMMANDS"))}>`;
-			messages.push(commandsUsage.padStart(ctx.env.leftMargin + commandsUsage.length));
-		}
-	} else {
-		const usageStr = `${await resolveEntry(ctx)} ${await resolveSubCommand(ctx)} ${[await generateOptionsSymbols(ctx), generatePositionalSymbols(ctx)].filter(Boolean).join(" ")}`;
-		messages.push(usageStr.padStart(ctx.env.leftMargin + usageStr.length));
-	}
+	const usageStr = await makeUsageSymbols(ctx);
+	messages.push(usageStr.padStart(ctx.env.leftMargin + usageStr.length));
 	return messages;
 }
+async function makeUsageSymbols(ctx) {
+	const messages = [await resolveEntry(ctx)];
+	if (ctx.omitted) if (await hasCommands(ctx)) messages.push(` [${await ctx.extensions[pluginId].text(resolveBuiltInKey("COMMANDS"))}]`);
+	else messages.push(`${ctx.callMode === "subCommand" ? ` ${await resolveSubCommand(ctx)}` : ""}`);
+	else messages.push(`${ctx.callMode === "subCommand" ? ` ${await resolveSubCommand(ctx)}` : ""}`);
+	const optionsSymbols = await generateOptionsSymbols(ctx, ctx.args);
+	if (optionsSymbols) messages.push(" ", optionsSymbols);
+	const positionalSymbols = generatePositionalSymbols(ctx.args);
+	if (positionalSymbols) messages.push(" ", positionalSymbols);
+	return messages.join("");
+}
 /**
 * Render the commands section
 * @param ctx A {@link CommandContext | command context}
@@ -240,19 +312,38 @@ async function renderCommandsSection(ctx) {
 	const messages = [`${await ctx.extensions[pluginId].text(resolveBuiltInKey("COMMANDS"))}:`];
 	const loadedCommands = await ctx.extensions?.[pluginId].loadCommands() || [];
 	const commandMaxLength = Math.max(...loadedCommands.map((cmd) => (cmd.name || "").length));
-	const commandsStr = await Promise.all(loadedCommands.map((cmd) => {
-		const key = cmd.name || "";
+	const commandsStr = await Promise.all(loadedCommands.map(async (cmd) => {
 		const desc = cmd.description || "";
-		const command = `${key.padEnd(commandMaxLength + ctx.env.middleMargin)}${desc} `;
-		return `${command.padStart(ctx.env.leftMargin + command.length)} `;
+		const optionSymbol = await generateOptionsSymbols(ctx, ctx.args);
+		const positionalSymbol = generatePositionalSymbols(ctx.args);
+		const commandStr = await makeCommandSymbol(ctx, cmd);
+		const symbolLength = desc.length > 0 ? commandMaxLength + optionSymbol.length + positionalSymbol.length : 0;
+		const command = `${commandStr.padEnd(symbolLength + ctx.env.middleMargin)}${desc}`;
+		return `${command.padStart(ctx.env.leftMargin + command.length)}`;
 	}));
 	messages.push(...commandsStr, "", `${await ctx.extensions[pluginId].text(resolveBuiltInKey("FORMORE"))}:`);
 	messages.push(...loadedCommands.map((cmd) => {
-		const commandHelp = `${ctx.env.name} ${cmd.name} --help`;
+		let commandStr = cmd.entry ? "" : cmd.name || "";
+		if (commandStr) commandStr += " ";
+		const commandHelp = `${ctx.env.name} ${commandStr}--help`;
 		return `${commandHelp.padStart(ctx.env.leftMargin + commandHelp.length)}`;
 	}));
 	return messages;
 }
+async function makeCommandSymbol(ctx, cmd) {
+	const optionSymbol = await generateOptionsSymbols(ctx, ctx.args);
+	const positionalSymbol = generatePositionalSymbols(ctx.args);
+	let commandStr = cmd.entry ? cmd.name === void 0 || cmd.name === ANONYMOUS_COMMAND_NAME ? "" : `[${cmd.name}]` : cmd.name || "";
+	if (optionSymbol) {
+		if (commandStr) commandStr += " ";
+		commandStr += `${optionSymbol}`;
+	}
+	if (positionalSymbol) {
+		if (commandStr) commandStr += " ";
+		commandStr += `${positionalSymbol}`;
+	}
+	return commandStr;
+}
 /**
 * Resolve the entry command name
 * @param ctx A {@link CommandContext | command context}
@@ -275,7 +366,7 @@ async function resolveSubCommand(ctx) {
 * @returns resolved command description
 */
 async function resolveDescription(ctx) {
-	return await ctx.extensions[pluginId].text("description") || ctx.description || "";
+	return await ctx.extensions[pluginId].text(resolveKey("description", ctx)) || ctx.description || "";
 }
 /**
 * Resolve the command examples
@@ -283,7 +374,7 @@ async function resolveDescription(ctx) {
 * @returns resolved command examples, if not resolved, return empty string
 */
 async function resolveExamples(ctx) {
-	const ret = await ctx.extensions[pluginId].text("examples");
+	const ret = await ctx.extensions[pluginId].text(resolveKey("examples", ctx));
 	if (ret) return ret;
 	const command = ctx.env.subCommands?.get(ctx.name || "");
 	return await resolveExamples$1(ctx, command?.examples);
@@ -299,41 +390,35 @@ async function hasCommands(ctx) {
 }
 /**
 * Check if the command has optional arguments
-* @param ctx A {@link CommandContext | command context}
+* @param args A {@link Args | command optional arguments}
 * @returns True if the command has options
 */
-function hasOptionalArgs(ctx) {
-	return !!(ctx.args && Object.values(ctx.args).some((arg) => arg.type !== "positional"));
+function hasOptionalArgs(args) {
+	return Object.values(args).some((arg) => arg.type !== "positional");
 }
 /**
 * Check if the command has positional arguments
-* @param ctx A {@link CommandContext | command context}
+* @param args A {@link Args | command positional arguments}
 * @returns True if the command has options
 */
-function hasPositionalArgs(ctx) {
-	return !!(ctx.args && Object.values(ctx.args).some((arg) => arg.type === "positional"));
+function hasPositionalArgs(args) {
+	return Object.values(args).some((arg) => arg.type === "positional");
 }
 /**
 * Check if all options have default values
-* @param ctx A {@link CommandContext | command context}
+* @param args An {@link Args | command argument}
 * @returns True if all options have default values
 */
-function hasAllDefaultOptions(ctx) {
-	return !!(ctx.args && Object.values(ctx.args).every((arg) => arg.default));
+function hasAllDefaultOptions(args) {
+	return !!(args && Object.values(args).every((arg) => arg.default));
 }
 /**
 * Generate options symbols for usage
 * @param ctx A {@link CommandContext | command context}
 * @returns Options symbols for usage
 */
-async function generateOptionsSymbols(ctx) {
-	return hasOptionalArgs(ctx) ? hasAllDefaultOptions(ctx) ? `[${await ctx.extensions[pluginId].text(resolveBuiltInKey("OPTIONS"))}]` : `<${await ctx.extensions[pluginId].text(resolveBuiltInKey("OPTIONS"))}>` : "";
-}
-function makeShortLongOptionPair(schema, name, toKebab) {
-	const displayName = toKebab || schema.toKebab ? kebabnize(name) : name;
-	let key = `--${displayName}`;
-	if (schema.short) key = `-${schema.short}, ${key}`;
-	return key;
+async function generateOptionsSymbols(ctx, args) {
+	return hasOptionalArgs(args) ? hasAllDefaultOptions(args) ? `[${await ctx.extensions[pluginId].text(resolveBuiltInKey("OPTIONS"))}]` : `<${await ctx.extensions[pluginId].text(resolveBuiltInKey("OPTIONS"))}>` : "";
 }
 /**
 * Get optional arguments pairs for usage
@@ -384,7 +469,7 @@ async function generateOptionalArgsUsage(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]) => resolveNegatableType(key, ctx).length)) : 0;
 	const usages = await Promise.all(Object.entries(optionsPairs).map(async ([key, value]) => {
-		let rawDesc = await ctx.extensions[pluginId].text(resolveArgKey(key));
+		let rawDesc = await ctx.extensions[pluginId].text(resolveArgKey(key, ctx));
 		if (!rawDesc && key.startsWith(ARG_NEGATABLE_PREFIX)) {
 			const name = resolveNegatableKey(key);
 			const schema = ctx.args[name];
@@ -394,26 +479,27 @@ async function generateOptionalArgsUsage(ctx, optionsPairs) {
 		const optionsSchema = ctx.env.usageOptionType ? `[${resolveNegatableType(key, ctx)}] ` : "";
 		const valueDesc = key.startsWith(ARG_NEGATABLE_PREFIX) ? "" : await resolveDisplayValue(ctx, key);
 		const desc = `${optionsSchema ? optionsSchema.padEnd(optionSchemaMaxLength + 3) : ""}${rawDesc}`;
-		const option = `${value.padEnd(optionsMaxLength + ctx.env.middleMargin)}${desc}${valueDesc ? ` ${valueDesc}` : ""}`;
+		const descLength = desc.length + valueDesc.length;
+		const option = `${value.padEnd((descLength > 0 ? optionsMaxLength : 0) + ctx.env.middleMargin)}${desc}${valueDesc ? ` ${valueDesc}` : ""}`;
 		return `${option.padStart(ctx.env.leftMargin + option.length)}`;
 	}));
 	return usages.join("\n");
 }
-function getPositionalArgs(ctx) {
-	return Object.entries(ctx.args).filter(([_, schema]) => schema.type === "positional");
+function getPositionalArgs(args) {
+	return Object.entries(args).filter(([_, schema]) => schema.type === "positional");
 }
 async function generatePositionalArgsUsage(ctx) {
-	const positionals = getPositionalArgs(ctx);
+	const positionals = getPositionalArgs(ctx.args);
 	const argsMaxLength = Math.max(...positionals.map(([name]) => name.length));
 	const usages = await Promise.all(positionals.map(async ([name]) => {
-		const desc = await ctx.extensions[pluginId].text(resolveArgKey(name)) || ctx.args[name].description || "";
+		const desc = await ctx.extensions[pluginId].text(resolveArgKey(name, ctx)) || ctx.args[name].description || "";
 		const arg = `${name.padEnd(argsMaxLength + ctx.env.middleMargin)} ${desc}`;
 		return `${arg.padStart(ctx.env.leftMargin + arg.length)}`;
 	}));
 	return usages.join("\n");
 }
-function generatePositionalSymbols(ctx) {
-	return hasPositionalArgs(ctx) ? getPositionalArgs(ctx).map(([name]) => `<${name}>`).join(" ") : "";
+function generatePositionalSymbols(args) {
+	return hasPositionalArgs(args) ? getPositionalArgs(args).map(([name]) => `<${name}>`).join(" ") : "";
 }
 
 //#endregion
@@ -450,29 +536,20 @@ function renderer() {
 			async function loadCommands() {
 				if (cachedCommands) return cachedCommands;
 				const subCommands = [...ctx.env.subCommands || []];
-				cachedCommands = await Promise.all(subCommands.map(async ([name, cmd$1]) => await resolveLazyCommand(cmd$1, name)));
+				const allCommands = await Promise.all(subCommands.map(async ([name, cmd$1]) => await resolveLazyCommand(cmd$1, name)));
+				cachedCommands = allCommands.filter((cmd$1) => !cmd$1.internal).filter(Boolean);
+				cachedCommands.sort((a, b) => {
+					if (a.entry && !b.entry) return -1;
+					if (!a.entry && b.entry) return 1;
+					if (a.name && b.name) return a.name.localeCompare(b.name);
+					if (a.name && !b.name) return -1;
+					if (!a.name && b.name) return 1;
+					return 0;
+				});
 				return cachedCommands;
 			}
-			async function text(key, values = Object.create(null)) {
-				if (i18n) return i18n.translate(key, values);
-				else if (key.startsWith(BUILD_IN_PREFIX_AND_KEY_SEPARATOR)) {
-					const resKey = key.slice(BUILD_IN_PREFIX_AND_KEY_SEPARATOR.length);
-					return en_US_default[resKey] || key;
-				} else if (key.startsWith(ARG_PREFIX_AND_KEY_SEPARATOR)) {
-					let argKey = key.slice(ARG_PREFIX_AND_KEY_SEPARATOR.length);
-					let negatable = false;
-					if (argKey.startsWith(ARG_NEGATABLE_PREFIX)) {
-						argKey = argKey.slice(ARG_NEGATABLE_PREFIX.length);
-						negatable = true;
-					}
-					const schema = ctx.args[argKey];
-					return negatable && schema.type === "boolean" && schema.negatable ? `${en_US_default["NEGATABLE"]} ${makeShortLongOptionPair(schema, argKey, ctx.toKebab)}` : schema.description || "";
-				} else if (key === "description") return "";
-				else if (key === "examples") return await resolveExamples$1(ctx, cmd.examples);
-				else return key;
-			}
 			return {
-				text,
+				text: localizable(ctx, cmd, i18n?.translate),
 				loadCommands
 			};
 		},

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gunshi/plugin-renderer",
   "description": "usage renderer plugin for gunshi",
-  "version": "0.26.3",
+  "version": "0.27.0-alpha.10",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -53,20 +53,20 @@
     }
   },
   "dependencies": {
-    "@gunshi/plugin": "0.26.3"
+    "@gunshi/plugin": "0.27.0-alpha.10"
   },
   "peerDependencies": {
-    "@gunshi/plugin-i18n": "0.26.3"
+    "@gunshi/plugin-i18n": "0.27.0-alpha.10"
   },
   "devDependencies": {
-    "deno": "^2.3.3",
-    "jsr": "^0.13.4",
+    "deno": "^2.4.2",
+    "jsr": "^0.13.5",
     "jsr-exports-lint": "^0.4.1",
     "publint": "^0.3.12",
-    "tsdown": "^0.12.3",
-    "typedoc": "^0.28.4",
-    "typedoc-plugin-markdown": "^4.6.3",
-    "@gunshi/shared": "0.26.3"
+    "tsdown": "^0.13.0",
+    "typedoc": "^0.28.7",
+    "typedoc-plugin-markdown": "^4.7.1",
+    "@gunshi/shared": "0.27.0-alpha.10"
   },
   "scripts": {
     "build": "tsdown",