@clerc/core 1.0.0-beta.9 → 1.0.0

package/dist/index.d.ts

@@ -1,22 +1,8 @@
-import { ErrorHandler as ErrorHandler$1 } from "lite-emit";
-
-//#region ../parser/src/flag-types.d.ts
-
-/**
-* Creates a Choices 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 FlagTypeFunction that validates and returns the input value
-* @throws {Error} If the value is not in the allowed values list
-*
-* @example
-* ```typescript
-* const format = Choices(['json', 'yaml', 'xml']);
-* // Help output will show: json | yaml | xml
-* ```
-*/
-declare function Choices<T extends string>(...values: T[]): FlagTypeFunction<T>;
+//#endregion
+//#region ../parser/src/errors.d.ts
+declare class InvalidSchemaError extends Error {
+  constructor(message: string);
+}
 //#endregion
 //#region ../utils/src/types/type-fest.d.ts
 type LiteralUnion<LiteralType, BaseType> = LiteralType | (BaseType & Record<never, never>);
@@ -29,6 +15,7 @@ type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown
 type ConditionalDeepPrettify<T, E = never, I$1 = unknown> = T extends E ? T : T extends I$1 ? { [TypeKey in keyof T]: ConditionalDeepPrettify<T[TypeKey], E, I$1> } : T;
 type DeepPrettify<T, E = never> = ConditionalDeepPrettify<T, E | NonRecursiveType | MapsSetsOrArrays, object>;
 type IsAny<T> = 0 extends 1 & T ? true : false;
+type RequireExactlyOneOrNone<T, Keys extends keyof T = keyof T> = ({ [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, never>> }[Keys] & Omit<T, Keys>) | (Partial<Record<Keys, never>> & Omit<T, Keys>);
 //#endregion
 //#region ../utils/src/types/index.d.ts
 type MaybeArray<T> = T | T[];
@@ -37,19 +24,24 @@ type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) ext
 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/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.
   */
-  displayName?: string;
-};
+  display?: string;
+}
 /**
 * A callback function to conditionally stop parsing.
 * When it returns true, parsing stops and remaining arguments are preserved in `ignored`.
@@ -59,19 +51,23 @@ 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>];
-interface BaseFlagOptions<T extends FlagType = FlagType> {
+type TypeValue<T = unknown> = TypeFunction<T> | readonly [TypeFunction<T>];
+type FlagRequiredOrDefault = RequireExactlyOneOrNone<{
+  /** The default value of the flag. */
+  default?: unknown;
+  /** Whether the flag is required. */
+  required?: boolean;
+}, "default" | "required">;
+type BaseFlagOptions<T extends TypeValue = TypeValue> = FlagRequiredOrDefault & {
   /**
   * The type constructor or a function to convert the string value.
   * To support multiple occurrences of a flag (e.g., --file a --file b), wrap the type in an array: [String], [Number].
   * e.g., String, Number, [String], (val) => val.split(',')
   */
   type: T;
-  /** Aliases for the flag. */
-  alias?: MaybeArray<string>;
-  /** The default value of the flag. */
-  default?: unknown;
-}
+  /** Short flag alias (single character). */
+  short?: string;
+};
 type FlagOptions = (BaseFlagOptions<BooleanConstructor> & {
   /**
   * Whether to enable the `--no-<flag>` syntax to set the value to false.
@@ -84,8 +80,30 @@ type FlagOptions = (BaseFlagOptions<BooleanConstructor> & {
 }) | (BaseFlagOptions & {
   negatable?: never;
 });
-type FlagDefinitionValue = FlagOptions | FlagType;
+type FlagDefinitionValue = FlagOptions | TypeValue;
 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;
@@ -110,6 +128,8 @@ interface ParsedResult<TFlags extends Record<string, any>> {
   unknown: Record<string, RawInputType>;
   /** Arguments that were not parsed due to ignore callback. */
   ignored: string[];
+  /** List of required flags that were not provided. */
+  missingRequiredFlags: string[];
 }
 type InferFlagDefault<T extends FlagDefinitionValue, Fallback> = T extends {
   default: FlagDefaultValue<infer DefaultType>;
@@ -119,13 +139,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>] | {
-  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 };
+} ? ObjectInputType | InferFlagDefault<T[K], never> : T[K] extends readonly [TypeValue<infer U>] | {
+  type: readonly [TypeValue<infer U>];
+} ? U[] | InferFlagDefault<T[K], never> : T[K] extends TypeValue<infer U> | {
+  type: TypeValue<infer U>;
+} ? 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.
@@ -141,40 +163,95 @@ declare const PARAMETER = "parameter";
 //#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, FlagDefaultValue, FlagDefaultValueFunction, FlagDefinitionValue, FlagOptions, FlagsDefinition, IgnoreFunction, InferFlags, InvalidSchemaError, KNOWN_FLAG, ObjectInputType, PARAMETER, ParsedResult, ParserOptions, RawInputType, TypeFunction, TypeValue, UNKNOWN_FLAG, createParser, parse };
+}
+//#endregion
+//#region ../advanced-types/src/errors.d.ts
+declare class FlagValidationError extends Error {}
+declare namespace index_d_exports$1 {
+  export { Enum, FlagValidationError, Range, Regex };
+}
+/**
+* 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 src/types/clerc.d.ts
 type ErrorHandler = (error: unknown) => void;
 //#endregion
 //#region src/types/flag.d.ts
 interface FlagCustomOptions {}
-type ClercFlagOptions = FlagOptions & FlagCustomOptions;
-type ClercGlobalFlagDefinitionValue = ClercFlagOptions | FlagType;
-type ClercFlagOptionsWithDescription = ClercFlagOptions & {
-  description: string;
-};
-type ClercFlagsDefinition = Record<string, ClercFlagOptionsWithDescription>;
+type ClercFlagOptions = FlagOptions & {
+  description?: string;
+} & FlagCustomOptions;
+type ClercFlagDefinitionValue = ClercFlagOptions | TypeValue;
+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 readonly string[]> = T extends readonly (infer U extends string)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+//#region src/types/parameter.d.ts
+interface ParameterCustomOptions {}
+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 ParameterDefinitionValue> = T extends string ? InferStringParameter<T> : T extends ParameterOptions ? T["type"] extends TypeFunction<infer U> ? InferStringParameter<T["key"], U> : InferStringParameter<T["key"]> : never;
+type InferParameters<T extends readonly ParameterDefinitionValue[]> = T extends readonly (infer U extends ParameterDefinitionValue)[] ? Prettify<UnionToIntersection<InferParameter<U>>> : never;
+type ParameterOptions = {
+  key: string;
+  description?: string;
+  type?: TypeFunction;
+} & ParameterCustomOptions;
+type ParameterDefinitionValue = string | ParameterOptions;
 //#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"]>>>>;
+type KnownKeys<T> = string extends keyof T ? never : keyof T;
+type InferFlagsWithGlobal<C extends Command, GF extends ClercFlagsDefinition> = AddStringIndex<InferFlags<NonNullable<C["flags"]> & Omit<GF, KnownKeys<NonNullable<C["flags"]>>>>>;
+interface ContextStore {}
 interface BaseContext<C extends Command = Command, GF extends ClercFlagsDefinition = {}> {
-  resolved: boolean;
   command?: C;
   calledAs?: string;
   parameters: InferParameters<NonNullable<C["parameters"]>>;
   flags: InferFlagsWithGlobal<C, GF>;
   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 readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
+interface CommandOptions<Parameters extends readonly ParameterDefinitionValue[] = readonly ParameterDefinitionValue[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandCustomOptions {
   alias?: MaybeArray<string>;
   parameters?: Parameters;
   flags?: Flags;
@@ -183,11 +260,11 @@ interface CommandOptions<Parameters extends readonly string[] = readonly string[
   */
   ignore?: IgnoreFunction;
 }
-interface Command<Name$1 extends string = string, Parameters extends readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
+interface Command<Name$1 extends string = string, Parameters extends readonly ParameterDefinitionValue[] = readonly ParameterDefinitionValue[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> extends CommandOptions<Parameters, Flags> {
   name: Name$1;
-  description: string;
+  description?: string;
 }
-type CommandWithHandler<Name$1 extends string = string, Parameters extends readonly string[] = readonly string[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
+type CommandWithHandler<Name$1 extends string = string, Parameters extends readonly ParameterDefinitionValue[] = readonly ParameterDefinitionValue[], Flags extends ClercFlagsDefinition = ClercFlagsDefinition> = Command<Name$1, Parameters, Flags> & {
   handler?: CommandHandler<Command<Name$1, Parameters, Flags>>;
 };
 type CommandsRecord = Record<string, Command>;
@@ -237,23 +314,27 @@ 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, const Parameters extends readonly string[] = readonly [], 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 string[] = readonly [], 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 ClercGlobalFlagDefinitionValue>(name: Name$1, description: string, options: Flag): Clerc<Commands, GlobalFlags & Record<Name$1, Flag>>;
+  errorHandler(handler: ErrorHandler): this;
+  command(commands: readonly CommandWithHandler<any, any, any>[]): this;
+  command<Name$1 extends string, const Parameters extends readonly ParameterDefinitionValue[], 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 ParameterDefinitionValue[], 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 ParameterDefinitionValue[], 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(): Promise<void>;
   parse<Run extends boolean = true>(argvOrOptions?: string[] | ParseOptions<Run>): Run extends true ? Promise<void> : this;
 }
 //#endregion
-//#region src/commands.d.ts
+//#region src/command.d.ts
 declare function resolveCommand(commandsMap: CommandsMap, parameters: string[]): [Command, string] | [undefined, undefined];
 //#endregion
 //#region src/errors.d.ts
@@ -264,23 +345,34 @@ declare class NoSuchCommandError extends Error {
 declare class NoCommandSpecifiedError extends Error {
   constructor(text?: string);
 }
-declare class InvalidCommandError extends Error {
-  constructor(message: string);
-}
+declare class InvalidCommandError extends Error {}
 declare class MissingRequiredMetadataError extends Error {
   constructor(metadataName: string);
 }
-declare class InvalidParametersError extends Error {
-  constructor(message: string);
+declare class InvalidParametersError extends Error {}
+declare class MissingRequiredFlagError extends Error {
+  constructor(flags: string[]);
 }
 //#endregion
 //#region src/helpers.d.ts
-declare const defineCommand: <Name$1 extends string, const Parameters extends readonly string[] = readonly [], Flags extends ClercFlagsDefinition = {}>(command: Command<Name$1, Parameters, Flags>, handler?: NoInfer<CommandHandler<Command<Name$1, Parameters, Flags>>>) => CommandWithHandler<Name$1, Parameters, Flags>;
+declare const defineCommand: <Name$1 extends string, const Parameters extends readonly ParameterDefinitionValue[], 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;
 //#endregion
+//#region src/parameter.d.ts
+interface ParameterInfo {
+  name: string;
+  isRequired: boolean;
+  isVariadic: boolean;
+}
+declare function extractParameterInfo(key: string): ParameterInfo;
+//#endregion
 //#region src/plugin.d.ts
 declare const definePlugin: (plugin: Plugin) => Plugin;
 //#endregion
-export { BaseContext, Choices, Clerc, ClercFlagOptions, ClercFlagOptionsWithDescription, ClercFlagsDefinition, ClercGlobalFlagDefinitionValue, Command, CommandCustomOptions, CommandHandler, CommandHandlerContext, CommandOptions, CommandWithHandler, CommandsMap, CommandsRecord, type CreateOptions, DOUBLE_DASH, ErrorHandler, FlagCustomOptions, InferParameters, Interceptor, InterceptorContext, InterceptorHandler, InterceptorNext, InterceptorObject, InvalidCommandError, InvalidParametersError, KNOWN_FLAG, MakeEmitterEvents, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, type ParseOptions, Plugin, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+//#region src/utils.d.ts
+declare const normalizeFlagValue: (flag: ClercFlagDefinitionValue) => ClercFlagOptions;
+declare const normalizeParameterValue: (parameter: ParameterDefinitionValue) => ParameterOptions;
+//#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, MissingRequiredFlagError, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, ParameterCustomOptions, ParameterDefinitionValue, ParameterOptions, type ParseOptions, type index_d_exports as Parser, Plugin, index_d_exports$1 as Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, extractParameterInfo, normalizeFlagValue, normalizeParameterValue, resolveCommand };

package/dist/index.js

@@ -1,8 +1,33 @@
-import { Choices, 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 * as Types from "@clerc/advanced-types";
+import { DOUBLE_DASH, DOUBLE_DASH as DOUBLE_DASH$1, InvalidSchemaError, KNOWN_FLAG, PARAMETER, PARAMETER as PARAMETER$1, UNKNOWN_FLAG, parse } from "@clerc/parser";
 import { LiteEmit } from "lite-emit";
 
-//#region src/commands.ts
+//#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/command.ts
 function resolveCommand(commandsMap, parameters) {
 	for (let i = parameters.length; i >= 0; i--) {
 		const name = parameters.slice(0, i).join(" ");
@@ -24,19 +49,17 @@ var NoCommandSpecifiedError = class extends Error {
 		super(text);
 	}
 };
-var InvalidCommandError = class extends Error {
-	constructor(message) {
-		super(message);
-	}
-};
+var InvalidCommandError = class extends Error {};
 var MissingRequiredMetadataError = class extends Error {
 	constructor(metadataName) {
 		super(`CLI ${metadataName} is required.`);
 	}
 };
-var InvalidParametersError = class extends Error {
-	constructor(message) {
-		super(message);
+var InvalidParametersError = class extends Error {};
+var MissingRequiredFlagError = class extends Error {
+	constructor(flags) {
+		const s = flags.length > 1 ? "s" : "";
+		super(`Missing required flag${s}: ${flags.join(", ")}`);
 	}
 };
 
@@ -73,7 +96,18 @@ function compose(inspectors) {
 }
 
 //#endregion
-//#region src/parameters.ts
+//#region ../../node_modules/.pnpm/is-platform@1.0.0/node_modules/is-platform/dist/index.mjs
+const IS_DENO = typeof Deno !== "undefined";
+const IS_NODE = typeof process !== "undefined" && !IS_DENO;
+const IS_ELECTRON = process.versions.electron && !process.defaultApp;
+
+//#endregion
+//#region src/utils.ts
+const normalizeFlagValue = (flag) => typeof flag === "function" || looseIsArray(flag) ? { type: flag } : flag;
+const normalizeParameterValue = (parameter) => typeof parameter === "string" ? { key: parameter } : parameter;
+
+//#endregion
+//#region src/parameter.ts
 function getParametersToResolve(argv) {
 	const parameters = [];
 	for (const arg of argv) {
@@ -84,15 +118,21 @@ function getParametersToResolve(argv) {
 }
 const PARAMETER_REGEX = /^(<|\[)([\w ]+)(\.\.\.)?(\]|>)$/;
 const isParameterDefinitionBracketsValid = (definition) => definition.startsWith("<") && definition.endsWith(">") || definition.startsWith("[") && definition.endsWith("]");
+function extractParameterInfo(key) {
+	const match = key.match(PARAMETER_REGEX);
+	if (!match || !isParameterDefinitionBracketsValid(key)) throw new InvalidParametersError(`Invalid parameter definition: ${key}`);
+	return {
+		name: camelCase(match[2]),
+		isRequired: key.startsWith("<"),
+		isVariadic: !!match[3]
+	};
+}
 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 name = camelCase(match[2]);
-		const isVariadic = !!match[3];
-		const isRequired = definition.startsWith("<");
+	for (const [i, def] of definitions.entries()) {
+		const normalized = normalizeParameterValue(def);
+		const { name, isRequired, isVariadic } = extractParameterInfo(normalized.key);
 		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 +140,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 (normalized.type) if (isVariadic) result[name] = value.map((v) => normalized.type(v));
+		else if (value === void 0) result[name] = value;
+		else result[name] = normalized.type(value);
+		else result[name] = value;
 	}
 	return result;
 }
@@ -117,12 +160,6 @@ function parseParameters(definitions, parameters, doubleDashParameters) {
 	}
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/is-platform@1.0.0/node_modules/is-platform/dist/index.mjs
-const IS_DENO = typeof Deno !== "undefined";
-const IS_NODE = typeof process !== "undefined" && !IS_DENO;
-const IS_ELECTRON = process.versions.electron && !process.defaultApp;
-
 //#endregion
 //#region src/platform.ts
 const platformArgv = IS_NODE ? process.argv.slice(IS_ELECTRON ? 1 : 2) : IS_DENO ? Deno.args : [];
@@ -132,8 +169,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 +202,9 @@ var Clerc = class Clerc {
 	get _globalFlags() {
 		return this.#globalFlags;
 	}
+	get store() {
+		return this.#store;
+	}
 	static create(options) {
 		return new Clerc(options);
 	}
@@ -211,13 +252,18 @@ 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) {
-		const command = typeof nameOrCommandObject === "string" ? {
-			name: nameOrCommandObject,
-			description,
-			...options
-		} : nameOrCommandObject;
-		const aliases = toArray(options?.alias ?? []);
+	command(nameOrCommandObjectOrCommandArray, descriptionOrOptions, options) {
+		if (Array.isArray(nameOrCommandObjectOrCommandArray)) {
+			for (const command$1 of nameOrCommandObjectOrCommandArray) this.command(command$1);
+			return this;
+		}
+		const isDescription = typeof descriptionOrOptions === "string";
+		const command = typeof nameOrCommandObjectOrCommandArray === "string" ? {
+			name: nameOrCommandObjectOrCommandArray,
+			description: isDescription ? descriptionOrOptions : void 0,
+			...isDescription ? options : descriptionOrOptions
+		} : nameOrCommandObjectOrCommandArray;
+		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 +273,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 +291,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) {
@@ -270,20 +316,20 @@ var Clerc = class Clerc {
 			parametersError = e;
 		}
 		const context = {
-			resolved: !!command,
 			command,
 			calledAs,
 			parameters,
 			flags: parsed.flags,
 			ignored: parsed.ignored,
 			rawParsed: parsed,
-			missingParameters: !!parametersError
+			store: { ...this.#store }
 		};
 		const emitInterceptor = {
 			enforce: "post",
-			handler: (ctx) => {
+			handler: async (ctx) => {
+				if (parsed.missingRequiredFlags.length > 0) throw new MissingRequiredFlagError(parsed.missingRequiredFlags);
 				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();
 			}
 		};
@@ -325,4 +371,4 @@ function createStopAtFirstParameter() {
 const definePlugin = (plugin) => plugin;
 
 //#endregion
-export { Choices, Clerc, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, KNOWN_FLAG, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, resolveCommand };
+export { Clerc, DOUBLE_DASH, InvalidCommandError, InvalidParametersError, InvalidSchemaError, KNOWN_FLAG, MissingRequiredFlagError, MissingRequiredMetadataError, NoCommandSpecifiedError, NoSuchCommandError, PARAMETER, Types, UNKNOWN_FLAG, createStopAtFirstParameter, defineCommand, definePlugin, extractParameterInfo, normalizeFlagValue, normalizeParameterValue, resolveCommand };

package/package.json

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