@bemoje/cli 2.0.1 → 2.0.2

package/lib/Command.d.ts

@@ -1,125 +1,149 @@
-import type { CamelCase, SetFieldType, Simplify, SetRequired } from 'type-fest';
+import type { ActionHandler } from './types';
+import type { AllowedArgumentUsage } from './types';
+import type { Argument } from './types';
+import type { Arguments } from './types';
+import type { BooleanOptionOptions } from './types';
+import type { CamelCase } from 'type-fest';
 import { Help } from './Help';
-import type { Arguments, Argument, ICommand, Option, Options, SubCommands } from './types';
-import type { ActionHandler, BooleanOptionOptions, AllowedArgumentUsage, InferAddedArgumentType, InferAddOptionResult, OptionalArgumentOptions, OptionalArgumentOptionsWithDefaultValue, OptionalOptionOptions, OptionalVariadicArgumentOptions, OptionalVariadicOptionOptions, RequiredArgumentOptions, RequiredOptionOptions, RequiredVariadicArgumentOptions, RequiredVariadicOptionOptions, ParseArgvResult, HookDefinition, HookActionHandler } from './types';
+import type { HookActionHandler } from './types';
+import type { HookDefinition } from './types';
+import type { ICommand } from './types';
+import type { InferAddOptionResult } from './types';
+import type { InferAddedArgumentType } from './types';
+import type { Option } from './types';
+import type { OptionalArgumentOptions } from './types';
+import type { OptionalArgumentOptionsWithDefaultValue } from './types';
+import type { OptionalOptionOptions } from './types';
+import type { OptionalVariadicArgumentOptions } from './types';
+import type { OptionalVariadicOptionOptions } from './types';
+import type { Options } from './types';
+import type { ParseArgvResult } from './types';
+import type { RequiredArgumentOptions } from './types';
+import type { RequiredOptionOptions } from './types';
+import type { RequiredVariadicArgumentOptions } from './types';
+import type { RequiredVariadicOptionOptions } from './types';
+import type { SetFieldType } from 'type-fest';
+import type { SetRequired } from 'type-fest';
+import type { Simplify } from 'type-fest';
+import type { SubCommands } from './types';
 /**
- * A type-safe CLI composer that can parse argv and generate help without execution coupling.
+ * a type-safe CLI composer that can parse argv and generate help without execution coupling.
  */
 export declare class Command<A extends Arguments = [], O extends Options = {
     help?: boolean;
     debug?: boolean;
 }, Subs extends SubCommands = SubCommands> implements ICommand {
-    /** Parent command in the hierarchy, undefined for root command */
+    /** parent command in the hierarchy, undefined for root command */
     parent?: Command<Arguments, Options & O>;
-    /** The command name used to invoke it */
+    /** the command name used to invoke it */
     name: string;
-    /** Semantic version string displayed by --version flag */
+    /** semantic version string displayed by --version flag */
     version?: string;
-    /** Alternative names for invoking this command */
+    /** alternative names for invoking this command */
     aliases: string[];
-    /** Brief one-line description shown in command lists */
+    /** brief one-line description shown in command lists */
     summary?: string;
-    /** Full description displayed in help text */
+    /** full description displayed in help text */
     description: string;
-    /** Whether to exclude from help listings */
+    /** whether to exclude from help listings */
     hidden?: boolean;
-    /** Category for organizing related commands in help output */
+    /** category for organizing related commands in help output */
     group?: string;
-    /** Positional arguments this command accepts */
+    /** positional arguments this command accepts */
     arguments: Argument[];
-    /** CLI options (flags) this command recognizes */
+    /** cLI options (flags) this command recognizes */
     options: Option[];
-    /** Subcommands registered with this command */
+    /** subcommands registered with this command */
     commands: Subs;
-    /** Main action handler executed when command is invoked */
+    /** main action handler executed when command is invoked */
     protected action?: ActionHandler<A, O, Subs>;
-    /** Option-driven actions (e.g., --help, --version) executed when their conditions match */
+    /** option-driven actions (e.g., --help, --version) executed when their conditions match */
     protected hooks: HookDefinition<Arguments, Options & O>[];
     constructor(name: string, parent?: ICommand);
     protected get help(): Help;
-    /** Configure how the help is rendered */
+    /** configure how the help is rendered */
     helpConfiguration(cb?: (help: Help) => void): this;
-    /** Renders formatted help text using provided help definition */
+    /** renders formatted help text using provided help definition */
     renderHelp(config?: {
         noColor?: boolean;
     }): string;
-    /** Sets the command name */
+    /** sets the command name */
     setName(name: string): void;
-    /** Sets command aliases, flattening nested arrays */
+    /** sets command aliases, flattening nested arrays */
     setAliases(...aliases: (string | string[])[]): this;
-    /** Adds aliases to existing ones */
+    /** adds aliases to existing ones */
     addAliases(...aliases: (string | string[])[]): this;
-    /** Sets the command version */
+    /** sets the command version */
     setVersion(version: string): InferAddOptionResult<A, O, {
         version?: boolean;
     }, Subs>;
-    /** Sets the command summary */
+    /** sets the command summary */
     setSummary(summary?: string): this;
-    /** Sets command description, joining variadic lines */
+    /** sets command description, joining variadic lines */
     setDescription(...lines: string[]): this;
-    /** Sets whether command is hidden from help */
+    /** sets whether command is hidden from help */
     setHidden(hidden?: boolean | undefined): this;
-    /** Sets the command group for help organization */
+    /** sets the command group for help organization */
     setGroup(group?: string): this;
-    /** Add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+    /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
     command<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(name: Name, cb?: (cmd: Command<[], O, {}>, parent: this) => Sub): Sub;
-    /** Add a subcommand and return the subcommand. All options are inherited by the subcommand. */
+    /** add a subcommand and return the subcommand. All options are inherited by the subcommand. */
     addCommand<Name extends string, Sub extends Command<any, any, any> = Command<[], O, {}>>(name: Name, cb: (cmd: Command<[], O, {}>, parent: this) => Sub): Command<A, O, (SubCommands extends Subs ? {} : Subs) & {
         [K in Name]: Sub;
     }>;
-    /** Add required variadic argument, eg.: `<name...>` */
+    /** add required variadic argument, eg.: `<name...>` */
     addArgument<const Opts extends RequiredVariadicArgumentOptions>(usage: AllowedArgumentUsage<this, `<${string}...>`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
-    /** Add required argument, eg.: `<name>` */
+    /** add required argument, eg.: `<name>` */
     addArgument<const Opts extends RequiredArgumentOptions>(usage: AllowedArgumentUsage<this, `<${string}>`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
-    /** Add optional variadic argument with defaults, eg.: `[name...]` */
+    /** add optional variadic argument with defaults, eg.: `[name...]` */
     addArgument<const Opts extends OptionalVariadicArgumentOptions>(usage: AllowedArgumentUsage<this, `[${string}...]`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts>[]], O, Subs>;
-    /** Add optional argument with default, eg.: `[name]` */
+    /** add optional argument with default, eg.: `[name]` */
     addArgument<const Opts extends OptionalArgumentOptionsWithDefaultValue>(usage: AllowedArgumentUsage<this, `[${string}]`>, options: Opts): Command<[...A, InferAddedArgumentType<Opts>], O, Subs>;
-    /** Add optional argument, eg.: `[name]` */
+    /** add optional argument, eg.: `[name]` */
     addArgument<const Opts extends OptionalArgumentOptions>(usage: AllowedArgumentUsage<this, `[${string}]`>, options?: Opts): Command<[...A, InferAddedArgumentType<Opts> | undefined], O, Subs>;
-    /** Add optional string option, eg.: `-o, --output [path]` */
+    /** add optional string option, eg.: `-o, --output [path]` */
     addOption<Long extends string>(flags: `-${string}, --${Long} [${string}]`, options?: SetFieldType<OptionalOptionOptions, 'defaultValue', undefined | never>): Command<A, Simplify<{
         [K in CamelCase<Long>]?: string;
     } & O>, Subs>;
-    /** Add optional string option with default, eg.: `-o, --output [path]` */
+    /** add optional string option with default, eg.: `-o, --output [path]` */
     addOption<Long extends string>(flags: `-${string}, --${Long} [${string}]`, options: SetFieldType<SetRequired<OptionalOptionOptions, 'defaultValue'>, 'defaultValue', string>): Command<A, Simplify<{
         [K in CamelCase<Long>]: string;
     } & O>, Subs>;
-    /** Add required variadic option, eg.: `-i, --include <patterns...>` */
+    /** add required variadic option, eg.: `-i, --include <patterns...>` */
     addOption<Long extends string>(flags: `-${string}, --${Long} <${string}...>`, options?: RequiredVariadicOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string[];
     } & O>, Subs>;
-    /** Add optional variadic option with defaults, eg.: `-e, --exclude [patterns...]` */
+    /** add optional variadic option with defaults, eg.: `-e, --exclude [patterns...]` */
     addOption<Long extends string>(flags: `-${string}, --${Long} [${string}...]`, options?: OptionalVariadicOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string[];
     } & O>, Subs>;
-    /** Add required string option, eg.: `-f, --file <path>` */
+    /** add required string option, eg.: `-f, --file <path>` */
     addOption<Long extends string>(flags: `-${string}, --${Long} <${string}>`, options?: RequiredOptionOptions): Command<A, Simplify<{
         [K in CamelCase<Long>]: string;
     } & O>, Subs>;
-    /** Add boolean flag option with default, eg.: `-v, --verbose` */
+    /** add boolean flag option with default, eg.: `-v, --verbose` */
     addOption<Long extends string>(flags: `-${string}, --${Long}`, options: SetFieldType<SetRequired<BooleanOptionOptions, 'defaultValue'>, 'defaultValue', boolean>): Command<A, Simplify<{
         [K in CamelCase<Long>]: boolean;
     } & O>, Subs>;
-    /** Add boolean flag option, eg.: `-v, --verbose` */
+    /** add boolean flag option, eg.: `-v, --verbose` */
     addOption<Long extends string>(flags: `-${string}, --${Long}`, options?: SetFieldType<BooleanOptionOptions, 'defaultValue', undefined | never>): Command<A, Simplify<{
         [K in CamelCase<Long>]?: boolean;
     } & O>, Subs>;
     /**
-     * Register an action to be invoked when an option is set to true or string value.
+     * register an action to be invoked when an option is set to true or string value.
      *
      * Hooks execute in addition to or instead of the main action handler,
      * allowing for option-driven behavior. For example, `--help` and `--version`
      * are implemented as hooks.
      */
     addOptionHook(optionName: keyof O, action: HookActionHandler<Arguments, O>): this;
-    /** Parses command-line arguments with subcommand support and type-safe validation. */
+    /** parses command-line arguments with subcommand support and type-safe validation. */
     parseArgv(argv?: string[]): ParseArgvResult<Arguments, Options & O>;
     /**
-     * Sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
+     * sets the main action handler for this command, which is executed after any matching option hooks when the command is invoked.
      * The handler receives parsed arguments and options with correct typings.
      */
     setAction(fn: ActionHandler<A, O, Subs>): this;
-    /** Returns a new Command instance. Override this method in subclasses. */
+    /** returns a new Command instance. Override this method in subclasses. */
     protected createSubcommand(name: string): Command<[], O, {}>;
 }

package/lib/Help.d.ts

@@ -1,4 +1,7 @@
-import type { IHelp, Argument, ICommand, Option } from './types';
+import type { Argument } from './types';
+import type { ICommand } from './types';
+import type { IHelp } from './types';
+import type { Option } from './types';
 /**
  * This is a fork of the Help class from the 'commander' npm package. The Help class method names as well as the
  * expected interface of the Command instance to parse, are both similar, but different and not compatible without

package/lib/helpers/findOption.d.ts

@@ -1,4 +1,5 @@
-import type { ICommand, Option } from '../types';
+import type { ICommand } from '../types';
+import type { Option } from '../types';
 /**
  * Finds option by name, short name or long name
  */

package/lib/internal/validateParsed.d.ts

@@ -1,3 +1,4 @@
-import type { Argument, Option } from '../types';
+import type { Argument } from '../types';
+import type { Option } from '../types';
 /** Validate parsed arguments and option values, returning errors or undefined */
 export declare function validateParsed(args: unknown[], optionValues: Record<string, unknown>, argDefs: Argument[], optionDefs: Option[]): string[] | undefined;

package/lib/types.d.ts

@@ -1,5 +1,8 @@
+import type { AllUnionFields } from 'type-fest';
 import type { Command } from './Command';
-import type { Simplify, AllUnionFields, SetFieldType, SetRequired } from 'type-fest';
+import type { SetFieldType } from 'type-fest';
+import type { SetRequired } from 'type-fest';
+import type { Simplify } from 'type-fest';
 /** Logger interface defining methods for different log levels. */
 export interface Logger {
     start: (...args: unknown[]) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bemoje/cli",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "A type-safe CLI composer that can parse argv and generate help without execution coupling.",
   "type": "module",
   "sideEffects": false,