@gunshi/shared 0.26.3

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 kazuya kawaguchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# `@gunshi/shared`
+
+shared utils for gunshi
+
+TODO(kazupon): more explanation
+
+## ©️ License
+
+[MIT](http://opensource.org/licenses/MIT)

package/lib/index.d.ts

@@ -0,0 +1,562 @@
+import en_US_default from "@gunshi/resources/en-US";
+
+//#region rolldown:runtime
+
+//#endregion
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/parser-FiQIAw-2.d.ts
+//#region src/parser.d.ts
+/**
+* Entry point of argument parser.
+* @module
+*/
+/**
+* forked from `nodejs/node` (`pkgjs/parseargs`)
+* repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
+* code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
+*
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Argument token Kind.
+* - `option`: option token, support short option (e.g. `-x`) and long option (e.g. `--foo`)
+* - `option-terminator`: option terminator (`--`) token, see guideline 10 in https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html
+* - `positional`: positional token
+*/
+type ArgTokenKind = "option" | "option-terminator" | "positional";
+/**
+* Argument token.
+*/
+interface ArgToken {
+  /**
+  * Argument token kind.
+  */
+  kind: ArgTokenKind;
+  /**
+  * Argument token index, e.g `--foo bar` => `--foo` index is 0, `bar` index is 1.
+  */
+  index: number;
+  /**
+  * Option name, e.g. `--foo` => `foo`, `-x` => `x`.
+  */
+  name?: string;
+  /**
+  * Raw option name, e.g. `--foo` => `--foo`, `-x` => `-x`.
+  */
+  rawName?: string;
+  /**
+  * Option value, e.g. `--foo=bar` => `bar`, `-x=bar` => `bar`.
+  * If the `allowCompatible` option is `true`, short option value will be same as Node.js `parseArgs` behavior.
+  */
+  value?: string;
+  /**
+  * Inline value, e.g. `--foo=bar` => `true`, `-x=bar` => `true`.
+  */
+  inlineValue?: boolean;
+} //#endregion
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/resolver-U72Jg6Ll.d.ts
+
+/**
+* Parser Options.
+*/
+//#region src/resolver.d.ts
+/**
+* An argument schema
+* This schema is similar to the schema of the `node:utils`.
+* difference is that:
+* - `required` property and `description` property are added
+* - `type` is not only 'string' and 'boolean', but also 'number', 'enum', 'positional', 'custom' too.
+* - `default` property type, not support multiple types
+*/
+interface ArgSchema {
+  /**
+  * Type of argument.
+  */
+  type: "string" | "boolean" | "number" | "enum" | "positional" | "custom";
+  /**
+  * A single character alias for the argument.
+  */
+  short?: string;
+  /**
+  * A description of the argument.
+  */
+  description?: string;
+  /**
+  * Whether the argument is required or not.
+  */
+  required?: true;
+  /**
+  * Whether the argument allow multiple values or not.
+  */
+  multiple?: true;
+  /**
+  * Whether the negatable option for `boolean` type
+  */
+  negatable?: boolean;
+  /**
+  * The allowed values of the argument, and string only. This property is only used when the type is 'enum'.
+  */
+  choices?: string[] | readonly string[];
+  /**
+  * The default value of the argument.
+  * if the type is 'enum', the default value must be one of the allowed values.
+  */
+  default?: string | boolean | number;
+  /**
+  * Whether to convert the argument name to kebab-case.
+  */
+  toKebab?: true;
+  /**
+  * A function to parse the value of the argument. if the type is 'custom', this function is required.
+  * If argument value will be invalid, this function have to throw an error.
+  * @param value
+  * @returns Parsed value
+  * @throws An Error, If the value is invalid. Error type should be `Error` or extends it
+  */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse?: (value: string) => any;
+}
+/**
+* An object that contains {@link ArgSchema | argument schema}.
+*/
+interface Args {
+  [option: string]: ArgSchema;
+}
+/**
+* An object that contains the values of the arguments.
+*/
+type ArgValues<T> = T extends Args ? ResolveArgValues<T, { [Arg in keyof T]: ExtractOptionValue<T[Arg]> }> : {
+  [option: string]: string | boolean | number | (string | boolean | number)[] | undefined;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type IsFunction<T> = T extends ((...args: any[]) => any) ? true : false;
+/**
+* @internal
+*/
+type ExtractOptionValue<A extends ArgSchema> = A["type"] extends "string" ? ResolveOptionValue<A, string> : A["type"] extends "boolean" ? ResolveOptionValue<A, boolean> : A["type"] extends "number" ? ResolveOptionValue<A, number> : A["type"] extends "positional" ? ResolveOptionValue<A, string> : A["type"] extends "enum" ? A["choices"] extends string[] | readonly string[] ? ResolveOptionValue<A, A["choices"][number]> : never : A["type"] extends "custom" ? IsFunction<A["parse"]> extends true ? ResolveOptionValue<A, ReturnType<NonNullable<A["parse"]>>> : never : ResolveOptionValue<A, string | boolean | number>;
+type ResolveOptionValue<A extends ArgSchema, T> = A["multiple"] extends true ? T[] : T;
+/**
+* @internal
+*/
+type ResolveArgValues<A extends Args, V extends Record<keyof A, unknown>> = { -readonly [Arg in keyof A]?: V[Arg] } & FilterArgs<A, V, "default"> & FilterArgs<A, V, "required"> & FilterPositionalArgs<A, V> extends infer P ? { [K in keyof P]: P[K] } : never;
+/**
+* @internal
+*/
+type FilterArgs<A extends Args, V extends Record<keyof A, unknown>, K extends keyof ArgSchema> = { [Arg in keyof A as A[Arg][K] extends {} ? Arg : never]: V[Arg] };
+/**
+* @internal
+*/
+type FilterPositionalArgs<A extends Args, V extends Record<keyof A, unknown>> = { [Arg in keyof A as A[Arg]["type"] extends "positional" ? Arg : never]: V[Arg] };
+
+//#endregion
+//#region ../gunshi/src/types.d.ts
+/**
+* An arguments for {@link resolveArgs | resolve arguments}.
+*/
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Extend command context type. This type is used to extend the command context with additional properties at {@link CommandContext.extensions}.
+ */
+type ExtendContext = Record<string, unknown>;
+/**
+ * Gunshi unified parameter type.
+ * This type combines both argument definitions and command context extensions.
+ */
+interface GunshiParams<P extends {
+  args?: Args;
+  extensions?: ExtendContext;
+} = {
+  args: Args;
+  extensions: {};
+}> {
+  /**
+   * Command argument definitions
+   */
+  args: P extends {
+    args: infer A extends Args;
+  } ? A : Args;
+  /**
+   * Command context extensions
+   */
+  extensions: P extends {
+    extensions: infer E extends ExtendContext;
+  } ? E : {};
+}
+/**
+ * Default Gunshi parameters
+ */
+type DefaultGunshiParams = GunshiParams;
+/**
+ * Generic constraint for command-related types.
+ * This type constraint allows both GunshiParams and objects with extensions.
+ */
+type GunshiParamsConstraint = GunshiParams<any> | {
+  extensions: ExtendContext;
+};
+/**
+ * Type helper to extract args from G
+ * @internal
+ */
+type ExtractArgs<G> = G extends GunshiParams<any> ? G['args'] : Args;
+/**
+ * Type helper to extract extensions from G
+ * @internal
+ */
+type ExtractExtensions<G> = G extends GunshiParams<any> ? G['extensions'] : G extends {
+  extensions: infer E;
+} ? E : {};
+/**
+ * Type helper to normalize G to GunshiParams
+ * @internal
+ */
+
+/**
+ * Command environment.
+ */
+interface CommandEnvironment<G extends GunshiParamsConstraint = DefaultGunshiParams> {
+  /**
+   * Current working directory.
+   * @see {@link CliOptions.cwd}
+   */
+  cwd: string | undefined;
+  /**
+   * Command name.
+   * @see {@link CliOptions.name}
+   */
+  name: string | undefined;
+  /**
+   * Command description.
+   * @see {@link CliOptions.description}
+   *
+   */
+  description: string | undefined;
+  /**
+   * Command version.
+   * @see {@link CliOptions.version}
+   */
+  version: string | undefined;
+  /**
+   * Left margin of the command output.
+   * @default 2
+   * @see {@link CliOptions.leftMargin}
+   */
+  leftMargin: number;
+  /**
+   * Middle margin of the command output.
+   * @default 10
+   * @see {@link CliOptions.middleMargin}
+   */
+  middleMargin: number;
+  /**
+   * Whether to display the usage option type.
+   * @default false
+   * @see {@link CliOptions.usageOptionType}
+   */
+  usageOptionType: boolean;
+  /**
+   * Whether to display the option value.
+   * @default true
+   * @see {@link CliOptions.usageOptionValue}
+   */
+  usageOptionValue: boolean;
+  /**
+   * Whether to display the command usage.
+   * @default false
+   * @see {@link CliOptions.usageSilent}
+   */
+  usageSilent: boolean;
+  /**
+   * Sub commands.
+   * @see {@link CliOptions.subCommands}
+   */
+  subCommands: Map<string, Command<any> | LazyCommand<any>> | undefined;
+  /**
+   * Render function the command usage.
+   */
+  renderUsage: ((ctx: Readonly<CommandContext<G>>) => Promise<string>) | null | undefined;
+  /**
+   * Render function the header section in the command usage.
+   */
+  renderHeader: ((ctx: Readonly<CommandContext<G>>) => Promise<string>) | null | undefined;
+  /**
+   * Render function the validation errors.
+   */
+  renderValidationErrors: ((ctx: Readonly<CommandContext<G>>, error: AggregateError) => Promise<string>) | null | undefined;
+  /**
+   * Hook that runs before any command execution
+   * @see {@link CliOptions.onBeforeCommand}
+   */
+  onBeforeCommand: ((ctx: Readonly<CommandContext<G>>) => Awaitable<void>) | undefined;
+  /**
+   * Hook that runs after successful command execution
+   * @see {@link CliOptions.onAfterCommand}
+   */
+  onAfterCommand: ((ctx: Readonly<CommandContext<G>>, result: string | void) => Awaitable<void>) | undefined;
+  /**
+   * Hook that runs when a command throws an error
+   * @see {@link CliOptions.onErrorCommand}
+   */
+  onErrorCommand: ((ctx: Readonly<CommandContext<G>>, error: Error) => Awaitable<void>) | undefined;
+}
+/**
+ * CLI options of `cli` function.
+ */
+
+/**
+ * Command call mode.
+ */
+type CommandCallMode = 'entry' | 'subCommand' | 'unexpected';
+/**
+ * Command context.
+ * Command context is the context of the command execution.
+ */
+interface CommandContext<G extends GunshiParamsConstraint = DefaultGunshiParams> {
+  /**
+   * Command name, that is the command that is executed.
+   * The command name is same {@link CommandEnvironment.name}.
+   */
+  name: string | undefined;
+  /**
+   * Command description, that is the description of the command that is executed.
+   * The command description is same {@link CommandEnvironment.description}.
+   */
+  description: string | undefined;
+  /**
+   * Command environment, that is the environment of the command that is executed.
+   * The command environment is same {@link CommandEnvironment}.
+   */
+  env: Readonly<CommandEnvironment<G>>;
+  /**
+   * Command arguments, that is the arguments of the command that is executed.
+   * The command arguments is same {@link Command.args}.
+   */
+  args: ExtractArgs<G>;
+  /**
+   * Command values, that is the values of the command that is executed.
+   * Resolve values with `resolveArgs` from command arguments and {@link Command.args}.
+   */
+  values: ArgValues<ExtractArgs<G>>;
+  /**
+   * Command positionals arguments, that is the positionals of the command that is executed.
+   * Resolve positionals with `resolveArgs` from command arguments.
+   */
+  positionals: string[];
+  /**
+   * Command rest arguments, that is the remaining argument not resolved by the optional command option delimiter `--`.
+   */
+  rest: string[];
+  /**
+   * Original command line arguments.
+   * This argument is passed from `cli` function.
+   */
+  _: string[];
+  /**
+   * Argument tokens, that is parsed by `parseArgs` function.
+   */
+  tokens: ArgToken[];
+  /**
+   * Whether the currently executing command has been executed with the sub-command name omitted.
+   */
+  omitted: boolean;
+  /**
+   * Command call mode.
+   * The command call mode is `entry` when the command is executed as an entry command, and `subCommand` when the command is executed as a sub-command.
+   */
+  callMode: CommandCallMode;
+  /**
+   * Whether to convert the camel-case style argument name to kebab-case.
+   * This context value is set from {@link Command.toKebab} option.
+   */
+  toKebab?: boolean;
+  /**
+   * Output a message.
+   * If {@link CommandEnvironment.usageSilent} is true, the message is not output.
+   * @param message an output message, @see {@link console.log}
+   * @param optionalParams an optional parameters, @see {@link console.log}
+   * @internal
+   */
+  log: (message?: any, ...optionalParams: any[]) => void;
+  /**
+   *  Command context extensions.
+   */
+  extensions: keyof ExtractExtensions<G> extends never ? undefined : ExtractExtensions<G>;
+  /**
+   * Validation error from argument parsing.
+   * This will be set if argument validation fails during CLI execution.
+   */
+  validationError?: AggregateError;
+}
+/**
+ * CommandContextCore type (base type without extensions)
+ */
+
+/**
+ * Command interface.
+ */
+interface Command<G extends GunshiParamsConstraint = DefaultGunshiParams> {
+  /**
+   * Command name.
+   * It's used to find command line arguments to execute from sub commands, and it's recommended to specify.
+   */
+  name?: string;
+  /**
+   * Command description.
+   * It's used to describe the command in usage and it's recommended to specify.
+   */
+  description?: string;
+  /**
+   * Command arguments.
+   * Each argument can include a description property to describe the argument in usage.
+   */
+  args?: ExtractArgs<G>;
+  /**
+   * Command examples.
+   * examples of how to use the command.
+   */
+  examples?: string | CommandExamplesFetcher<G>;
+  /**
+   * Command runner. it's the command to be executed
+   */
+  run?: CommandRunner<G>;
+  /**
+   * Whether to convert the camel-case style argument name to kebab-case.
+   * If you will set to `true`, All {@link Command.args} names will be converted to kebab-case.
+   */
+  toKebab?: boolean;
+}
+/**
+ * Lazy command interface.
+ * Lazy command that's not loaded until it is executed.
+ */
+type LazyCommand<G extends GunshiParamsConstraint = DefaultGunshiParams> = {
+  /**
+   * Command load function
+   */
+  (): Awaitable<Command<G> | CommandRunner<G>>;
+  /**
+   * Command name
+   */
+  commandName?: string;
+} & Omit<Command<G>, 'run' | 'name'>;
+/**
+ * Define a command type.
+ */
+type Commandable<G extends GunshiParamsConstraint = DefaultGunshiParams> = Command<G> | LazyCommand<G>;
+/**
+ * Command examples fetcher.
+ * @param ctx A {@link CommandContext | command context}
+ * @returns A fetched command examples.
+ */
+type CommandExamplesFetcher<G extends GunshiParamsConstraint = DefaultGunshiParams> = (ctx: Readonly<CommandContext<G>>) => Awaitable<string>;
+/**
+ * Command runner.
+ * @param ctx A {@link CommandContext | command context}
+ * @returns void or string (for CLI output)
+ */
+type CommandRunner<G extends GunshiParamsConstraint = DefaultGunshiParams> = (ctx: Readonly<CommandContext<G>>) => Awaitable<void | string>; //#endregion
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/utils.d.ts
+
+/**
+ * Command loader.
+ * A function that returns a command or command runner.
+ * This is used to lazily load commands.
+ * @returns A command or command runner
+ */
+//#region src/utils.d.ts
+/**
+* Entry point of utils.
+*
+* Note that this entry point is used by gunshi to import utility functions.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+declare function kebabnize(str: string): string;
+
+//#endregion
+//#region ../gunshi/src/utils.d.ts
+//#endregion
+declare function isLazyCommand<G extends GunshiParamsConstraint = DefaultGunshiParams>(cmd: unknown): cmd is LazyCommand<G>;
+declare function resolveLazyCommand<G extends GunshiParamsConstraint = DefaultGunshiParams>(cmd: Commandable<G>, name?: string | undefined, needRunResolving?: boolean): Promise<Command<G>>;
+declare function create<T>(obj?: object | null): T;
+declare function log(...args: unknown[]): void;
+declare function deepFreeze<T extends Record<string, any>>(obj: T, ignores?: string[]): Readonly<T>;
+
+//#endregion
+//#region src/constants.d.ts
+declare namespace constants_d_exports {
+  export { ARG_NEGATABLE_PREFIX, ARG_PREFIX, ARG_PREFIX_AND_KEY_SEPARATOR, BUILD_IN_PREFIX_AND_KEY_SEPARATOR, BUILT_IN_KEY_SEPARATOR, BUILT_IN_PREFIX, COMMAND_BUILTIN_RESOURCE_KEYS, COMMON_ARGS, PLUGIN_PREFIX };
+}
+/**
+ * @author kazuya kawaguchi (a.k.a. kazupon)
+ * @license MIT
+ */
+declare const BUILT_IN_PREFIX = "_";
+declare const PLUGIN_PREFIX = "g";
+declare const ARG_PREFIX = "arg";
+declare const BUILT_IN_KEY_SEPARATOR = ":";
+declare const BUILD_IN_PREFIX_AND_KEY_SEPARATOR: string;
+declare const ARG_PREFIX_AND_KEY_SEPARATOR: string;
+declare const ARG_NEGATABLE_PREFIX = "no-";
+type CommonArgType = {
+  readonly help: {
+    readonly type: 'boolean';
+    readonly short: 'h';
+    readonly description: string;
+  };
+  readonly version: {
+    readonly type: 'boolean';
+    readonly short: 'v';
+    readonly description: string;
+  };
+};
+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 src/types.d.ts
+type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+/**
+ * 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];
+/**
+ * Generate a namespaced key.
+ */
+type GenerateNamespacedKey<Key extends string, Prefixed extends string = typeof BUILT_IN_PREFIX> = `${Prefixed}${typeof BUILT_IN_KEY_SEPARATOR}${Key}`;
+/**
+ * Command i18n built-in arguments keys.
+ */
+type CommandBuiltinArgsKeys = keyof (typeof constants_d_exports)['COMMON_ARGS'];
+/**
+ * Command i18n built-in resource keys.
+ */
+type CommandBuiltinResourceKeys = (typeof constants_d_exports)['COMMAND_BUILTIN_RESOURCE_KEYS'][number];
+/**
+ * i18n 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.
+ */
+type CommandBuiltinKeys = GenerateNamespacedKey<BuiltinResourceKeys> | 'description' | 'examples';
+/**
+ * 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>;
+
+//#endregion
+//#region src/utils.d.ts
+declare function resolveBuiltInKey<K extends string = CommandBuiltinArgsKeys | CommandBuiltinResourceKeys>(key: K): GenerateNamespacedKey<K>;
+declare function resolveArgKey<A extends Args = DefaultGunshiParams['args'], K extends string = KeyOfArgs<RemovedIndex<A>>>(key: K): GenerateNamespacedKey<K, typeof ARG_PREFIX>;
+declare function resolveExamples<G extends GunshiParamsConstraint = DefaultGunshiParams>(ctx: Readonly<CommandContext<G>>, examples?: string | CommandExamplesFetcher<G>): Promise<string>;
+declare function namespacedId<K extends string>(id: K): GenerateNamespacedKey<K, typeof PLUGIN_PREFIX>;
+
+//#endregion
+export { ARG_NEGATABLE_PREFIX, ARG_PREFIX, ARG_PREFIX_AND_KEY_SEPARATOR, BUILD_IN_PREFIX_AND_KEY_SEPARATOR, BUILT_IN_KEY_SEPARATOR, BUILT_IN_PREFIX, BuiltinResourceKeys, COMMAND_BUILTIN_RESOURCE_KEYS, COMMON_ARGS, CommandArgKeys, CommandBuiltinArgsKeys, CommandBuiltinKeys, CommandBuiltinResourceKeys, en_US_default as DefaultResource, GenerateNamespacedKey, KeyOfArgs, PLUGIN_PREFIX, RemovedIndex, create, deepFreeze, isLazyCommand, kebabnize, log, namespacedId, resolveArgKey, resolveBuiltInKey, resolveExamples, resolveLazyCommand };

package/lib/index.js

@@ -0,0 +1,152 @@
+//#region ../../node_modules/.pnpm/args-tokens@0.20.1/node_modules/args-tokens/lib/utils-N7UlhLbz.js
+/**
+* Entry point of utils.
+*
+* Note that this entry point is used by gunshi to import utility functions.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+function kebabnize(str) {
+	return str.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+
+//#endregion
+//#region ../gunshi/src/utils.ts
+function isLazyCommand(cmd) {
+	return typeof cmd === "function" && "commandName" in cmd && !!cmd.commandName;
+}
+async function resolveLazyCommand(cmd, name, needRunResolving = false) {
+	let command;
+	if (isLazyCommand(cmd)) {
+		const baseCommand = {
+			name: cmd.commandName,
+			description: cmd.description,
+			args: cmd.args,
+			examples: cmd.examples
+		};
+		if ("resource" in cmd && cmd.resource) baseCommand.resource = cmd.resource;
+		command = Object.assign(create(), baseCommand);
+		if (needRunResolving) {
+			const loaded = await cmd();
+			if (typeof loaded === "function") command.run = loaded;
+			else if (typeof loaded === "object") {
+				if (loaded.run == null) throw new TypeError(`'run' is required in command: ${cmd.name || name}`);
+				command.run = loaded.run;
+				command.name = loaded.name;
+				command.description = loaded.description;
+				command.args = loaded.args;
+				command.examples = loaded.examples;
+				if ("resource" in loaded && loaded.resource) command.resource = loaded.resource;
+			} else throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
+		}
+	} else command = Object.assign(create(), cmd);
+	if (command.name == null && name) command.name = name;
+	return deepFreeze(command);
+}
+function create(obj = null) {
+	return Object.create(obj);
+}
+function log(...args) {
+	console.log(...args);
+}
+function deepFreeze(obj, ignores = []) {
+	if (obj === null || typeof obj !== "object") return obj;
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (ignores.includes(key)) continue;
+		if (typeof value === "object" && value !== null) deepFreeze(value, ignores);
+	}
+	return Object.freeze(obj);
+}
+
+//#endregion
+//#region src/constants.ts
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const BUILT_IN_PREFIX = "_";
+const PLUGIN_PREFIX = "g";
+const ARG_PREFIX = "arg";
+const BUILT_IN_KEY_SEPARATOR = ":";
+const BUILD_IN_PREFIX_AND_KEY_SEPARATOR = `${BUILT_IN_PREFIX}${BUILT_IN_KEY_SEPARATOR}`;
+const ARG_PREFIX_AND_KEY_SEPARATOR = `${ARG_PREFIX}${BUILT_IN_KEY_SEPARATOR}`;
+const ARG_NEGATABLE_PREFIX = "no-";
+const COMMON_ARGS = {
+	help: {
+		type: "boolean",
+		short: "h",
+		description: "Display this help message"
+	},
+	version: {
+		type: "boolean",
+		short: "v",
+		description: "Display this version"
+	}
+};
+const COMMAND_BUILTIN_RESOURCE_KEYS = [
+	"USAGE",
+	"COMMAND",
+	"SUBCOMMAND",
+	"COMMANDS",
+	"ARGUMENTS",
+	"OPTIONS",
+	"EXAMPLES",
+	"FORMORE",
+	"NEGATABLE",
+	"DEFAULT",
+	"CHOICES"
+];
+
+//#endregion
+//#region ../resources/locales/en-US.json
+var COMMAND = "COMMAND";
+var COMMANDS = "COMMANDS";
+var SUBCOMMAND = "SUBCOMMAND";
+var USAGE = "USAGE";
+var ARGUMENTS = "ARGUMENTS";
+var OPTIONS = "OPTIONS";
+var EXAMPLES = "EXAMPLES";
+var FORMORE = "For more info, run any command with the `--help` flag";
+var NEGATABLE = "Negatable of";
+var DEFAULT = "default";
+var CHOICES = "choices";
+var help = "Display this help message";
+var version = "Display this version";
+var en_US_default = {
+	COMMAND,
+	COMMANDS,
+	SUBCOMMAND,
+	USAGE,
+	ARGUMENTS,
+	OPTIONS,
+	EXAMPLES,
+	FORMORE,
+	NEGATABLE,
+	DEFAULT,
+	CHOICES,
+	help,
+	version
+};
+
+//#endregion
+//#region src/utils.ts
+function resolveBuiltInKey(key) {
+	return `${BUILT_IN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
+function resolveArgKey(key) {
+	return `${ARG_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
+async function resolveExamples(ctx, examples) {
+	return typeof examples === "string" ? examples : typeof examples === "function" ? await examples(ctx) : "";
+}
+function namespacedId(id) {
+	return `${PLUGIN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${id}`;
+}
+
+//#endregion
+export { ARG_NEGATABLE_PREFIX, ARG_PREFIX, ARG_PREFIX_AND_KEY_SEPARATOR, BUILD_IN_PREFIX_AND_KEY_SEPARATOR, BUILT_IN_KEY_SEPARATOR, BUILT_IN_PREFIX, COMMAND_BUILTIN_RESOURCE_KEYS, COMMON_ARGS, en_US_default as DefaultResource, PLUGIN_PREFIX, create, deepFreeze, isLazyCommand, kebabnize, log, namespacedId, resolveArgKey, resolveBuiltInKey, resolveExamples, resolveLazyCommand };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@gunshi/shared",
+  "description": "shared utils for gunshi",
+  "version": "0.26.3",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/kazupon",
+  "bugs": {
+    "url": "https://github.com/kazupon/gunshi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kazupon/gunshi.git",
+    "directory": "packages/shared"
+  },
+  "keywords": [
+    "gunshi",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "type": "module",
+  "files": [
+    "lib"
+  ],
+  "module": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./lib/*",
+        "./*"
+      ]
+    }
+  },
+  "devDependencies": {
+    "deno": "^2.3.3",
+    "jsr": "^0.13.4",
+    "jsr-exports-lint": "^0.4.1",
+    "publint": "^0.3.12",
+    "tsdown": "^0.12.3",
+    "gunshi": "0.26.3",
+    "@gunshi/resources": "0.26.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint:jsr": "jsr publish --dry-run --allow-dirty",
+    "typecheck:deno": "deno check --import-map=../../importmap.json ./src"
+  }
+}