@clerc/core 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/chunk-CYeTv9WL.js

@@ -0,0 +1,42 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget, symbols) => {
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+		secondTarget && __defProp(secondTarget, Symbol.toStringTag, { value: "Module" });
+	}
+	__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default");
+};
+
+//#endregion
+export { __reExport as n, __export as t };

package/dist/index.d.ts

@@ -1,5 +1,14 @@
-import { ErrorHandler as ErrorHandler$1 } from "lite-emit";
+import { n as __reExport, t as __export } from "./chunk-CYeTv9WL.js";
+import { Clerc as Clerc$1, CreateOptions as CreateOptions$1, Plugin as Plugin$1 } from "@clerc/core";
 
+//#region ../parser/src/errors.d.ts
+declare class InvalidSchemaError extends Error {
+  constructor(message: string);
+}
+declare class MissingRequiredFlagError extends Error {
+  constructor(name: string);
+}
+//#endregion
 //#region ../utils/src/types/type-fest.d.ts
 type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
@@ -18,14 +27,30 @@ type PartialRequired<T, K$1 extends keyof T> = T & { [P in K$1]-?: T[P] };
 type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
 type CamelCase<S extends string> = S extends `${infer Head} ${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S;
 //#endregion
+//#region ../parser/src/iterator.d.ts
+declare const KNOWN_FLAG = "known-flag";
+declare const UNKNOWN_FLAG = "unknown-flag";
+declare const PARAMETER = "parameter";
+//#endregion
 //#region ../parser/src/types.d.ts
-type FlagDefaultValue<T = unknown> = T | (() => T);
+interface FlagDefaultValueFunction<T> {
+  (): T;
+  display?: string;
+}
+type FlagDefaultValue<T = unknown> = T | FlagDefaultValueFunction<T>;
 /**
 * Defines how a string input is converted to the target type T.
 *
 * @template T The target type.
 */
-type FlagTypeFunction<T = unknown> = (value: string) => T;
+interface TypeFunction<T = unknown> {
+  (value: string): T;
+  /**
+  * Optional display name for the type, useful in help output.
+  * If provided, this will be shown instead of the function name.
+  */
+  display?: string;
+}
 /**
 * A callback function to conditionally stop parsing.
 * When it returns true, parsing stops and remaining arguments are preserved in `ignored`.
@@ -35,7 +60,7 @@ type FlagTypeFunction<T = unknown> = (value: string) => T;
 * @returns true to stop parsing, false to continue
 */
 type IgnoreFunction = (type: typeof KNOWN_FLAG | typeof UNKNOWN_FLAG | typeof PARAMETER, arg: string) => boolean;
-type FlagType<T = unknown> = FlagTypeFunction<T> | readonly [FlagTypeFunction<T>];
+type FlagType<T = unknown> = TypeFunction<T> | readonly [TypeFunction<T>];
 interface BaseFlagOptions<T extends FlagType = FlagType> {
   /**
   * The type constructor or a function to convert the string value.
@@ -47,6 +72,8 @@ interface BaseFlagOptions<T extends FlagType = FlagType> {
   alias?: MaybeArray<string>;
   /** The default value of the flag. */
   default?: unknown;
+  /** Whether the flag is required. */
+  required?: boolean;
 }
 type FlagOptions = (BaseFlagOptions<BooleanConstructor> & {
   /**
@@ -62,6 +89,28 @@ type FlagOptions = (BaseFlagOptions<BooleanConstructor> & {
 });
 type FlagDefinitionValue = FlagOptions | FlagType;
 type FlagsDefinition = Record<string, FlagDefinitionValue>;
+/**
+* Configuration options for the parser.
+*/
+interface ParserOptions<T extends FlagsDefinition = {}> {
+  /**
+  * Detailed configuration for flags.
+  * Supports the full object syntax or a type constructor as a shorthand.
+  * The key is the flag name (e.g., "file" for "--file").
+  */
+  flags?: T;
+  /**
+  * Delimiters to split flag names and values.
+  *
+  * @default ['=', ':']
+  */
+  delimiters?: string[];
+  /**
+  * A callback function to conditionally stop parsing.
+  * When it returns true, parsing stops and remaining arguments are preserved in `ignored`.
+  */
+  ignore?: IgnoreFunction;
+}
 type RawInputType = string | boolean;
 interface ObjectInputType {
   [key: string]: RawInputType | ObjectInputType;
@@ -95,13 +144,15 @@ type IsTypeAny<T extends FlagDefinitionValue> = IsAny<T> extends true ? true : T
 } ? IsAny<Type> extends true ? true : false : false;
 type _InferFlags<T extends FlagsDefinition> = { [K in keyof T]: IsTypeAny<T[K]> extends true ? any : T[K] extends readonly [BooleanConstructor] | {
   type: readonly [BooleanConstructor];
-} ? number : T[K] extends ObjectConstructor | {
+} ? number | InferFlagDefault<T[K], never> : T[K] extends ObjectConstructor | {
   type: ObjectConstructor;
-} ? ObjectInputType : T[K] extends readonly [FlagType<infer U>] | {
+} ? ObjectInputType | InferFlagDefault<T[K], never> : T[K] extends readonly [FlagType<infer U>] | {
   type: readonly [FlagType<infer U>];
 } ? U[] | InferFlagDefault<T[K], never> : T[K] extends FlagType<infer U> | {
   type: FlagType<infer U>;
-} ? U | InferFlagDefault<T[K], [U] extends [boolean] ? never : undefined> : never };
+} ? U | InferFlagDefault<T[K], [U] extends [boolean] ? never : T[K] extends {
+  required: true;
+} ? never : undefined> : never };
 /**
 * An advanced utility type that infers the exact type of the `flags` object in the parsed result,
 * based on the provided `flags` configuration object T.
@@ -110,30 +161,78 @@ type _InferFlags<T extends FlagsDefinition> = { [K in keyof T]: IsTypeAny<T[K]>
 */
 type InferFlags<T extends FlagsDefinition> = Prettify<_InferFlags<T>>;
 //#endregion
-//#region ../parser/src/iterator.d.ts
-declare const KNOWN_FLAG = "known-flag";
-declare const UNKNOWN_FLAG = "unknown-flag";
-declare const PARAMETER = "parameter";
+//#region ../parser/src/flag-types.d.ts
+/**
+* Creates a Enum type function that validates the input against allowed values.
+* The display name will be formatted as "value1 | value2 | ..." for help output.
+*
+* @param values - Array of allowed string values
+* @returns A TypeFunction that validates and returns the input value
+* @throws {Error} If the value is not in the allowed values list
+*
+* @example
+* ```typescript
+* const format = Enum(['json', 'yaml', 'xml']);
+* // Help output will show: json | yaml | xml
+* ```
+*/
+declare function Enum<T extends string>(...values: T[]): TypeFunction<T>;
+/**
+* Creates a range type function that validates the input is a number within the specified range.
+*
+* @param min - The minimum acceptable value (inclusive)
+* @param max - The maximum acceptable value (inclusive)
+* @returns A TypeFunction that validates the input value
+* @throws {Error} If the value is not a number or is outside the specified range
+*/
+declare function Range(min: number, max: number): TypeFunction<number>;
+/**
+* Creates a regex type function that validates the input against the provided pattern.
+*
+* @param pattern - The regular expression pattern to validate against
+* @param description - Optional description for display purposes
+* @returns A TypeFunction that validates the input value
+* @throws {Error} If the value does not match the regex pattern
+*/
+declare function Regex(pattern: RegExp, description?: string): TypeFunction<string>;
 //#endregion
 //#region ../parser/src/parse.d.ts
 declare const DOUBLE_DASH = "--";
+type ParseFunction<T extends FlagsDefinition> = (args: string[]) => ParsedResult<InferFlags<T>>;
+declare function createParser<T extends FlagsDefinition>(options?: ParserOptions<T>): {
+  parse: ParseFunction<T>;
+};
+declare const parse: <T extends FlagsDefinition>(args: string[], options?: ParserOptions<T>) => ParsedResult<InferFlags<T>>;
+declare namespace index_d_exports {
+  export { BaseFlagOptions, DOUBLE_DASH, Enum, FlagDefaultValue, FlagDefaultValueFunction, FlagDefinitionValue, FlagOptions, FlagType, FlagsDefinition, IgnoreFunction, InferFlags, InvalidSchemaError, KNOWN_FLAG, MissingRequiredFlagError, ObjectInputType, PARAMETER, ParsedResult, ParserOptions, Range, RawInputType, Regex, TypeFunction, UNKNOWN_FLAG, createParser, parse };
+}
 //#endregion
 //#region src/types/clerc.d.ts
 type ErrorHandler = (error: unknown) => void;
 //#endregion
 //#region src/types/flag.d.ts
+interface FlagCustomOptions {}
 type ClercFlagOptions = FlagOptions & {
-  description: string;
-};
-type ClercFlagsDefinition = Record<string, ClercFlagOptions>;
+  description?: string;
+} & FlagCustomOptions;
+type ClercFlagDefinitionValue = ClercFlagOptions | FlagType;
+type ClercFlagsDefinition = Record<string, ClercFlagDefinitionValue>;
 //#endregion
 //#region src/types/parameters.d.ts
-type InferParameter<T extends string> = T extends `<${infer Name extends string}...>` | `[${infer Name extends string}...]` ? Record<CamelCase<Name>, string[]> : T extends `<${infer Name extends string}>` ? Record<CamelCase<Name>, string> : T extends `[${infer Name extends string}]` ? Record<CamelCase<Name>, string | undefined> : never;
-type InferParameters<T extends string[]> = T extends (infer U extends string)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+type InferStringParameter<T extends string, Type$1 = string> = T extends `<${infer Name extends string}...>` | `[${infer Name extends string}...]` ? Record<CamelCase<Name>, Type$1[]> : T extends `<${infer Name extends string}>` ? Record<CamelCase<Name>, Type$1> : T extends `[${infer Name extends string}]` ? Record<CamelCase<Name>, Type$1 | undefined> : never;
+type InferParameter<T extends Parameter> = T extends string ? InferStringParameter<T> : T extends ParameterDefinition ? T["type"] extends TypeFunction<infer U> ? InferStringParameter<T["key"], U> : InferStringParameter<T["key"]> : never;
+type InferParameters<T extends readonly Parameter[]> = T extends readonly (infer U extends Parameter)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+interface ParameterDefinition {
+  key: string;
+  description?: string;
+  type?: TypeFunction;
+}
+type Parameter = string | ParameterDefinition;
 //#endregion
 //#region src/types/context.d.ts
 type AddStringIndex<T> = T & Record<string, any>;
 type InferFlagsWithGlobal<C extends Command, GF extends ClercFlagsDefinition> = AddStringIndex<InferFlags<NonNullable<C["flags"]> & Omit<GF, keyof NonNullable<C["flags"]>>>>;
+interface ContextStore {}
 interface BaseContext<C extends Command = Command, GF extends ClercFlagsDefinition = {}> {
   resolved: boolean;
   command?: C;
@@ -143,11 +242,12 @@ interface BaseContext<C extends Command = Command, GF extends ClercFlagsDefiniti
   ignored: string[];
   rawParsed: ParsedResult<InferFlagsWithGlobal<C, GF>>;
   missingParameters: boolean;
+  store: Partial<ContextStore>;
 }
 //#endregion
 //#region src/types/command.d.ts
 interface CommandCustomOptions {}
-interface CommandOptions<Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
+interface CommandOptions<Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
   alias?: MaybeArray<string>;
   parameters?: Parameters;
   flags?: Flags;
@@ -156,11 +256,11 @@ interface CommandOptions<Parameters extends string[] = string[], Flags extends C
   */
   ignore?: IgnoreFunction;
 }
-interface Command<Name$1 extends string = string, Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
+interface Command<Name$1 extends string = string, Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
   name: Name$1;
-  description: string;
+  description?: string;
 }
-type CommandWithHandler<Name$1 extends string = string, Parameters extends string[] = string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
+type CommandWithHandler<Name$1 extends string = string, Parameters extends readonly Parameter[] = readonly Parameter[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
   handler?: CommandHandler<Command<Name$1, Parameters, Flags>>;
 };
 type CommandsRecord = Record<string, Command>;
@@ -197,9 +297,9 @@ interface CreateOptions {
   description?: string;
   version?: string;
 }
-interface ParseOptions {
+interface ParseOptions<Run extends boolean = true> {
   argv?: string[];
-  run?: boolean;
+  run?: Run;
 }
 declare class Clerc<Commands extends CommandsRecord = {}, GlobalFlags extends ClercFlagsDefinition = {}> {
   #private;
@@ -210,20 +310,23 @@ declare class Clerc<Commands extends CommandsRecord = {}, GlobalFlags extends Cl
   get _version(): string;
   get _commands(): CommandsMap;
   get _globalFlags(): GlobalFlags;
+  get store(): Partial<ContextStore>;
   static create(options?: CreateOptions): Clerc;
   name(name: string): this;
   scriptName(scriptName: string): this;
   description(description: string): this;
   version(version: string): this;
   use(plugin: Plugin): this;
-  errorHandler(handler: ErrorHandler$1): this;
-  command<Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, [...Parameters], Flags>): Clerc<Commands & Record<string, CommandWithHandler<Name$1, Parameters, Flags>>, GlobalFlags>;
-  command<Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, description: string, options?: CommandOptions<[...Parameters], Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
-  globalFlag<Name$1 extends string, Flag extends FlagDefinitionValue>(name: Name$1, description: string, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
+  errorHandler(handler: ErrorHandler): this;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, Parameters, Flags>): Clerc<Commands & Record<string, CommandWithHandler<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, options?: CommandOptions<Parameters, Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
+  command<Name$1 extends string, const Parameters extends readonly Parameter[], Flags extends ClercFlagsDefinition = {}>(name: Name$1 extends keyof Commands ? ["COMMAND ALREADY EXISTS"] : Name$1, description: string, options?: CommandOptions<Parameters, Flags>): Clerc<Commands & Record<Name$1, Command<Name$1, Parameters, Flags>>, GlobalFlags>;
+  globalFlag<Name$1 extends string, Flag extends ClercFlagDefinitionValue>(name: Name$1, description: string, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
+  globalFlag<Name$1 extends string, Flag extends ClercFlagDefinitionValue>(name: Name$1, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
   interceptor(interceptor: Interceptor<Command, GlobalFlags>): this;
   on<Name$1 extends LiteralUnion<keyof Commands, string>>(name: Name$1, handler: CommandHandler<Commands[Name$1], GlobalFlags>): this;
-  run(): void;
-  parse(argvOrOptions?: string[] | ParseOptions): this;
+  run(): Promise<void>;
+  parse<Run extends boolean = true>(argvOrOptions?: string[] | ParseOptions<Run>): Run extends true ? Promise<void> : this;
 }
 //#endregion
 //#region src/commands.d.ts
@@ -246,9 +349,12 @@ declare class MissingRequiredMetadataError extends Error {
 declare class InvalidParametersError extends Error {
   constructor(message: string);
 }
+declare namespace flag_types_d_exports {
+  export { Enum, Range, Regex };
+}
 //#endregion
 //#region src/helpers.d.ts
-declare const defineCommand: <Name$1 extends string, Parameters extends string[] = [], Flags extends ClercFlagsDefinition = {}>(command: CommandWithHandler<Name$1, [...Parameters], Flags>) => CommandWithHandler<Name$1, [...Parameters], Flags>;
+declare const defineCommand: <Name$1 extends string, const Parameters extends readonly Parameter[], Flags extends ClercFlagsDefinition = {}>(command: Command<Name$1, Parameters, Flags>, handler?: NoInfer<CommandHandler<Command<Name$1, Parameters, Flags>>>) => CommandWithHandler<Name$1, Parameters, Flags>;
 //#endregion
 //#region src/ignore.d.ts
 declare function createStopAtFirstParameter(): IgnoreFunction;
@@ -256,4 +362,203 @@ declare function createStopAtFirstParameter(): IgnoreFunction;
 //#region src/plugin.d.ts
 declare const definePlugin: (plugin: Plugin) => Plugin;
 //#endregion
-export { BaseContext, Clerc, ClercFlagOptions, ClercFlagsDefinition, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, DOUBLE_DASH, ErrorHandler, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, KNOWN_FLAG, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, Plugin, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+//#region ../plugin-completions/src/index.d.ts
+declare module "@clerc/core" {
+  interface CommandCustomOptions {
+    /**
+    * Completions options for the command.
+    */
+    completions?: {
+      /**
+      * Whether to show the command in completions output.
+      *
+      * @default true
+      */
+      show?: boolean;
+    };
+  }
+}
+interface CompletionsPluginOptions {
+  /**
+  * Whether to register the `completions install` and `completions uninstall` commands.
+  * @default true
+  */
+  managementCommands?: boolean;
+}
+declare const completionsPlugin: (options?: CompletionsPluginOptions) => Plugin$1;
+//#endregion
+//#region ../plugin-friendly-error/src/index.d.ts
+interface FriendlyErrorPluginOptions {
+  target?: (str: string) => void;
+}
+declare const friendlyErrorPlugin: ({
+  target
+}?: FriendlyErrorPluginOptions) => Plugin$1;
+//#endregion
+//#region ../plugin-help/src/types.d.ts
+interface Formatters {
+  formatFlagType: (type: FlagType) => string;
+  formatFlagDefault: <T>(value: FlagDefaultValue<T>) => string;
+}
+/**
+* A group definition as a tuple of [key, displayName].
+* The key is used in help options to assign items to groups.
+* The displayName is shown in the help output.
+*/
+type GroupDefinition = [key: string, name: string];
+/**
+* Options for defining groups in help output.
+*/
+interface GroupsOptions {
+  /**
+  * Groups for commands.
+  * Each group is defined as `[key, name]`.
+  */
+  commands?: GroupDefinition[];
+  /**
+  * Groups for command-specific flags.
+  * Each group is defined as `[key, name]`.
+  */
+  flags?: GroupDefinition[];
+  /**
+  * Groups for global flags.
+  * Each group is defined as `[key, name]`.
+  */
+  globalFlags?: GroupDefinition[];
+}
+//#endregion
+//#region ../plugin-help/src/formatters.d.ts
+declare const defaultFormatters: Formatters;
+//#endregion
+//#region ../plugin-help/src/index.d.ts
+interface HelpOptions {
+  /**
+  * The group this item belongs to.
+  * The group must be defined in the `groups` option of `helpPlugin()`.
+  */
+  group?: string;
+}
+interface CommandHelpOptions extends HelpOptions {
+  /**
+  * Whether to show the command in help output.
+  *
+  * @default true
+  */
+  show?: boolean;
+  /**
+  * Notes to show in the help output.
+  */
+  notes?: string[];
+  /**
+  * Examples to show in the help output.
+  * Each example is a tuple of `[command, description]`.
+  */
+  examples?: [string, string][];
+}
+declare module "@clerc/core" {
+  interface CommandCustomOptions {
+    /**
+    * Help options for the command.
+    */
+    help?: CommandHelpOptions;
+  }
+  interface FlagCustomOptions {
+    /**
+    * Help options for the flag.
+    */
+    help?: HelpOptions;
+  }
+}
+interface HelpPluginOptions {
+  /**
+  * Whether to register the `help` command.
+  *
+  * @default true
+  */
+  command?: boolean;
+  /**
+  * Whether to register the `--help` global flag.
+  *
+  * @default true
+  */
+  flag?: boolean;
+  /**
+  * Whether to show help when no command is specified.
+  *
+  * @default true
+  */
+  showHelpWhenNoCommandSpecified?: boolean;
+  /**
+  * Notes to show in the help output.
+  */
+  notes?: string[];
+  /**
+  * Examples to show in the help output.
+  * Each example is a tuple of `[command, description]`.
+  */
+  examples?: [string, string][];
+  /**
+  * A banner to show before the help output.
+  */
+  banner?: string;
+  /**
+  * Custom formatters for rendering help.
+  */
+  formatters?: Partial<Formatters>;
+  /**
+  * Group definitions for commands and flags.
+  * Groups allow organizing commands and flags into logical sections in help output.
+  * Each group is defined as `[key, name]` where `key` is the identifier used in help options
+  * and `name` is the display name shown in help output.
+  */
+  groups?: GroupsOptions;
+}
+declare const helpPlugin: ({
+  command,
+  flag,
+  showHelpWhenNoCommandSpecified,
+  notes,
+  examples,
+  banner,
+  formatters,
+  groups
+}?: HelpPluginOptions) => Plugin$1;
+//#endregion
+//#region ../plugin-not-found/src/index.d.ts
+declare const notFoundPlugin: () => Plugin$1;
+//#endregion
+//#region ../plugin-strict-flags/src/index.d.ts
+declare const strictFlagsPlugin: () => Plugin$1;
+//#endregion
+//#region ../plugin-version/src/index.d.ts
+interface VersionPluginOptions {
+  /**
+  * Whether to register the version command.
+  *
+  * @default true
+  */
+  command?: boolean;
+  /**
+  * Whether to register the global version flag.
+  *
+  * @default true
+  */
+  flag?: boolean;
+}
+declare const versionPlugin: ({
+  command,
+  flag
+}?: VersionPluginOptions) => Plugin$1;
+declare namespace re_exports_d_exports {
+  export { CommandHelpOptions, CompletionsPluginOptions, FriendlyErrorPluginOptions, GroupDefinition, GroupsOptions, HelpOptions, HelpPluginOptions, completionsPlugin, defaultFormatters, friendlyErrorPlugin, helpPlugin, notFoundPlugin, strictFlagsPlugin, versionPlugin };
+}
+import * as import___clerc_core from "@clerc/core";
+declare namespace index_d_exports$1 {
+  export { Cli, CommandHelpOptions, CompletionsPluginOptions, FriendlyErrorPluginOptions, GroupDefinition, GroupsOptions, HelpOptions, HelpPluginOptions, completionsPlugin, defaultFormatters, friendlyErrorPlugin, helpPlugin, notFoundPlugin, strictFlagsPlugin, versionPlugin };
+}
+declare const Cli: (options?: CreateOptions$1) => Clerc$1;
+//#endregion
+//#region src/utils.d.ts
+declare const normalizeFlagValue: (flag: index_d_exports$1.ClercFlagDefinitionValue) => index_d_exports$1.ClercFlagOptions;
+//#endregion
+export { BaseContext, Clerc, ClercFlagDefinitionValue, ClercFlagOptions, ClercFlagsDefinition, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, ContextStore, type CreateOptions, DOUBLE_DASH, ErrorHandler, FlagCustomOptions, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, Parameter, ParameterDefinition, type ParseOptions, type index_d_exports as Parser, Plugin, flag_types_d_exports as Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, normalizeFlagValue, resolveCommand };

package/dist/index.js

@@ -1,7 +1,32 @@
-import { DOUBLE_DASH, DOUBLE_DASH as DOUBLE_DASH$1, KNOWN_FLAG, PARAMETER, PARAMETER as PARAMETER$1, UNKNOWN_FLAG, parse } from "@clerc/parser";
-import { camelCase, toArray } from "@clerc/utils";
+import { t as __export } from "./chunk-CYeTv9WL.js";
+import { DOUBLE_DASH, DOUBLE_DASH as DOUBLE_DASH$1, Enum, InvalidSchemaError, KNOWN_FLAG, PARAMETER, PARAMETER as PARAMETER$1, Range, Regex, UNKNOWN_FLAG, parse } from "@clerc/parser";
 import { LiteEmit } from "lite-emit";
 
+//#region ../utils/src/index.ts
+const looseIsArray = (arr) => Array.isArray(arr);
+const toArray = (a) => Array.isArray(a) ? a : [a];
+/**
+* Converts a dash- or space-separated string to camelCase.
+* Not using regexp for better performance, because this function is used in parser.
+*/
+function camelCase(str) {
+	const firstIdx = Math.min(str.includes("-") ? str.indexOf("-") : Infinity, str.includes(" ") ? str.indexOf(" ") : Infinity);
+	if (firstIdx === Infinity) return str;
+	let result = str.slice(0, firstIdx);
+	for (let i = firstIdx; i < str.length; i++) if ((str[i] === "-" || str[i] === " ") && i + 1 < str.length) {
+		const nextChar = str.charCodeAt(i + 1);
+		if (nextChar >= 97 && nextChar <= 122) {
+			result += String.fromCharCode(nextChar - 32);
+			i++;
+		} else {
+			result += str[i + 1];
+			i++;
+		}
+	} else if (str[i] !== "-" && str[i] !== " ") result += str[i];
+	return result;
+}
+
+//#endregion
 //#region src/commands.ts
 function resolveCommand(commandsMap, parameters) {
 	for (let i = parameters.length; i >= 0; i--) {
@@ -88,11 +113,12 @@ function _parseParameters(definitions, parameters) {
 	const result = {};
 	let hasOptional = false;
 	for (const [i, definition] of definitions.entries()) {
-		const match = definition.match(PARAMETER_REGEX);
-		if (!match || !isParameterDefinitionBracketsValid(definition)) throw new InvalidParametersError(`Invalid parameter definition: ${definition}`);
+		const definitionKey = typeof definition === "string" ? definition : definition.key;
+		const match = definitionKey.match(PARAMETER_REGEX);
+		if (!match || !isParameterDefinitionBracketsValid(definitionKey)) throw new InvalidParametersError(`Invalid parameter definition: ${definitionKey}`);
 		const name = camelCase(match[2]);
 		const isVariadic = !!match[3];
-		const isRequired = definition.startsWith("<");
+		const isRequired = definitionKey.startsWith("<");
 		if (name in result) throw new InvalidParametersError(`Duplicate parameter name: ${name}`);
 		if (isVariadic && i !== definitions.length - 1) throw new InvalidParametersError("Variadic parameter must be the last parameter in the definition.");
 		if (isRequired) {
@@ -100,7 +126,10 @@ function _parseParameters(definitions, parameters) {
 		} else hasOptional = true;
 		const value = isVariadic ? parameters.slice(i) : parameters[i];
 		if (isRequired && (isVariadic ? value.length === 0 : value === void 0)) throw new InvalidParametersError(`Missing required ${isVariadic ? "variadic " : ""}parameter: ${name}`);
-		result[name] = value;
+		if (typeof definition !== "string" && definition.type) if (isVariadic) result[name] = value.map((v) => definition.type(v));
+		else if (value === void 0) result[name] = value;
+		else result[name] = definition.type(value);
+		else result[name] = value;
 	}
 	return result;
 }
@@ -132,8 +161,9 @@ const platformArgv = IS_NODE ? process.argv.slice(IS_ELECTRON ? 1 : 2) : IS_DENO
 var Clerc = class Clerc {
 	#argv = [];
 	#commands = /* @__PURE__ */ new Map();
-	#emitter = new LiteEmit({ errorHandler: (error) => this.#handleError(error) });
+	#emitter = new LiteEmit();
 	#globalFlags = {};
+	#store = {};
 	#interceptors = [];
 	#errorHandlers = [];
 	#name = "";
@@ -164,6 +194,9 @@ var Clerc = class Clerc {
 	get _globalFlags() {
 		return this.#globalFlags;
 	}
+	get store() {
+		return this.#store;
+	}
 	static create(options) {
 		return new Clerc(options);
 	}
@@ -198,7 +231,7 @@ var Clerc = class Clerc {
 	#callWithErrorHandler(fn) {
 		try {
 			const result = fn();
-			if (result instanceof Promise) result.catch((error) => {
+			if (result instanceof Promise) return result.catch((error) => {
 				this.#handleError(error);
 			});
 			return result;
@@ -211,13 +244,14 @@ var Clerc = class Clerc {
 		if (this.#commands.has(name)) throw new InvalidCommandError(`Command with name "${name}" already exists.`);
 		for (const alias of aliases) if (this.#commands.has(alias)) throw new InvalidCommandError(`Command with name "${alias}" already exists.`);
 	}
-	command(nameOrCommandObject, description, options) {
+	command(nameOrCommandObject, descriptionOrOptions, options) {
+		const isDescription = typeof descriptionOrOptions === "string";
 		const command = typeof nameOrCommandObject === "string" ? {
 			name: nameOrCommandObject,
-			description,
-			...options
+			description: isDescription ? descriptionOrOptions : void 0,
+			...isDescription ? options : descriptionOrOptions
 		} : nameOrCommandObject;
-		const aliases = toArray(options?.alias ?? []);
+		const aliases = toArray(command?.alias ?? []);
 		this.#callWithErrorHandler(() => this.#validateCommandNameAndAlias(command.name, aliases));
 		this.#commands.set(command.name, command);
 		for (const alias of aliases) this.#commands.set(alias, {
@@ -227,10 +261,11 @@ var Clerc = class Clerc {
 		if (command.handler) this.on(command.name, command.handler);
 		return this;
 	}
-	globalFlag(name, description, options) {
+	globalFlag(name, descriptionOrOptions, options) {
+		const isDescription = typeof descriptionOrOptions === "string";
 		this.#globalFlags[name] = {
-			description,
-			...options
+			description: isDescription ? descriptionOrOptions : void 0,
+			...isDescription ? options : descriptionOrOptions
 		};
 		return this;
 	}
@@ -244,7 +279,6 @@ var Clerc = class Clerc {
 	}
 	#validate() {
 		if (!this.#scriptName) throw new MissingRequiredMetadataError("script name");
-		if (!this.#description) throw new MissingRequiredMetadataError("description");
 		if (!this.#version) throw new MissingRequiredMetadataError("version");
 	}
 	#parseArgv(argv, command) {
@@ -257,7 +291,7 @@ var Clerc = class Clerc {
 			ignore
 		}));
 	}
-	run() {
+	async run() {
 		const parametersToResolve = getParametersToResolve(this.#argv);
 		const [command, calledAs] = resolveCommand(this.#commands, parametersToResolve);
 		const argvToPass = command && calledAs.length > 0 ? this.#argv.slice(calledAs.split(" ").length) : this.#argv;
@@ -277,32 +311,44 @@ var Clerc = class Clerc {
 			flags: parsed.flags,
 			ignored: parsed.ignored,
 			rawParsed: parsed,
-			missingParameters: !!parametersError
+			missingParameters: !!parametersError,
+			store: { ...this.#store }
 		};
 		const emitInterceptor = {
 			enforce: "post",
-			handler: (ctx) => {
+			handler: async (ctx) => {
 				if (parametersError) throw parametersError;
-				if (command) this.#emitter.emit(command.name, ctx);
+				if (command) await this.#emitter.emit(command.name, ctx);
 				else throw parametersToResolve.length > 0 ? new NoSuchCommandError(parametersToResolve.join(" ")) : new NoCommandSpecifiedError();
 			}
 		};
 		const composedInterceptor = compose([...this.#interceptors, emitInterceptor]);
-		this.#callWithErrorHandler(() => composedInterceptor(context));
+		return this.#callWithErrorHandler(() => composedInterceptor(context));
 	}
 	parse(argvOrOptions = platformArgv) {
 		this.#callWithErrorHandler(() => this.#validate());
 		if (Array.isArray(argvOrOptions)) argvOrOptions = { argv: argvOrOptions };
 		const { argv = platformArgv, run = true } = argvOrOptions;
 		this.#argv = argv;
-		if (run) this.run();
+		if (run) return this.run();
 		return this;
 	}
 };
 
+//#endregion
+//#region src/flag-types.ts
+var flag_types_exports = /* @__PURE__ */ __export({
+	Enum: () => Enum,
+	Range: () => Range,
+	Regex: () => Regex
+});
+
 //#endregion
 //#region src/helpers.ts
-const defineCommand = (command) => command;
+const defineCommand = (command, handler) => ({
+	...command,
+	handler
+});
 
 //#endregion
 //#region src/ignore.ts
@@ -322,4 +368,8 @@ function createStopAtFirstParameter() {
 const definePlugin = (plugin) => plugin;
 
 //#endregion
-export { Clerc, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, KNOWN_FLAG, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+//#region src/utils.ts
+const normalizeFlagValue = (flag) => typeof flag === "function" || looseIsArray(flag) ? { type: flag } : flag;
+
+//#endregion
+export { Clerc, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, flag_types_exports as Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, normalizeFlagValue, resolveCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clerc/core",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.21",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve)",
   "type": "module",
   "description": "Clerc core",
@@ -44,15 +44,11 @@
     "access": "public"
   },
   "dependencies": {
-    "lite-emit": "^3.1.0",
-    "@clerc/parser": "^1.0.0-beta.2",
-    "@clerc/utils": "1.0.0-beta.2"
+    "lite-emit": "^4.0.0",
+    "@clerc/parser": "^1.0.0-beta.21"
   },
   "devDependencies": {
-    "is-platform": "^1.0.0"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "watch": "tsdown --watch"
+    "is-platform": "^1.0.0",
+    "@clerc/utils": "1.0.0-beta.21"
   }
 }