bob-core 0.9.12 → 1.0.1

package/README.md

@@ -2,7 +2,7 @@
 
 ## Introduction
 
-BOB (Bash Operation Buddy) Core is a library that provides a set of functions to create your own CLI in TypeScript.
+BOB (Bash Operation Buddy) Core is a library that provides a set of functions to create your own CLI in TypeScript easily.
 
 ## Usage
 

package/dist/Cli.d.ts

@@ -2,6 +2,11 @@ import { CommandRegistry } from "./CommandRegistry";
 import { Command } from "./Command";
 import HelpCommand from "./commands/HelpCommand";
 import { ExceptionHandler } from "./ExceptionHandler";
+export type CliOptions<C> = {
+    ctx?: C;
+    name?: string;
+    version?: string;
+};
 export declare class Cli<C> {
     readonly commandRegistry: CommandRegistry;
     private readonly exceptionHandler;
@@ -10,7 +15,7 @@ export declare class Cli<C> {
     get CommandRegistryClass(): typeof CommandRegistry;
     get HelpCommandClass(): typeof HelpCommand;
     get ExceptionHandlerClass(): typeof ExceptionHandler;
-    constructor(ctx?: C);
+    constructor(opts?: CliOptions<C>);
     setCommandResolver(resolver: (path: string) => Promise<Command<C>>): void;
     withCommands(...commands: Array<Command<C> | {
         new (): Command<C>;

package/dist/Cli.js

@@ -21,11 +21,15 @@ class Cli {
     get ExceptionHandlerClass() {
         return ExceptionHandler_1.ExceptionHandler;
     }
-    constructor(ctx) {
-        this.ctx = ctx;
+    constructor(opts = {}) {
+        this.ctx = opts.ctx;
         this.commandRegistry = new this.CommandRegistryClass();
         this.exceptionHandler = new this.ExceptionHandlerClass();
-        this.helpCommand = new this.HelpCommandClass(this.commandRegistry);
+        this.helpCommand = new this.HelpCommandClass({
+            cliName: opts.name,
+            cliVersion: opts.version,
+            commandRegistry: this.commandRegistry
+        });
     }
     setCommandResolver(resolver) {
         this.commandRegistry.setCommandResolver(resolver);

package/dist/Command.d.ts

@@ -1,10 +1,10 @@
-import { CommandHelper } from "./CommandHelper";
-import { ArgSignature, CommandParser } from "./CommandParser";
+import { CommandParser } from "./CommandParser";
+import { CommandOption } from "./contracts/CommandOption";
 export type CommandExample = {
     description: string;
     command: string;
 };
-export declare abstract class Command<C = any> extends CommandHelper {
+export declare abstract class Command<C = any> {
     abstract signature: string;
     abstract description: string;
     protected ctx: C;
@@ -15,7 +15,7 @@ export declare abstract class Command<C = any> extends CommandHelper {
     protected parser: CommandParser;
     protected abstract handle(): Promise<void | number>;
     private get CommandParserClass();
-    protected get defaultOptions(): ArgSignature[];
+    protected defaultOptions(): CommandOption<Command<C>>[];
     get command(): string;
     run(ctx: C, ...args: any[]): Promise<number>;
     protected setOption(name: string, value: any): void;

package/dist/Command.js

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
-const CommandHelper_1 = require("./CommandHelper");
 const CommandParser_1 = require("./CommandParser");
-const chalk_1 = __importDefault(require("chalk"));
-class Command extends CommandHelper_1.CommandHelper {
+const HelpOption_1 = require("./options/HelpOption");
+class Command {
     ctx;
     helperDefinitions = {};
     commandsExamples = [];
@@ -15,16 +11,8 @@ class Command extends CommandHelper_1.CommandHelper {
     get CommandParserClass() {
         return CommandParser_1.CommandParser;
     }
-    get defaultOptions() {
-        return [
-            {
-                name: 'help',
-                optional: true,
-                type: 'boolean',
-                help: (0, chalk_1.default) `Display help for the given command. When no command is given display help for the {green list} command`,
-                alias: ['h']
-            }
-        ];
+    defaultOptions() {
+        return [new HelpOption_1.HelpOption];
     }
     get command() {
         if (this.parser) {
@@ -34,9 +22,15 @@ class Command extends CommandHelper_1.CommandHelper {
     }
     async run(ctx, ...args) {
         this.ctx = ctx;
-        this.parser = new this.CommandParserClass(this.signature, this.helperDefinitions, this.defaultOptions, ...args);
-        if (args.includes('--help') || args.includes('-h')) {
-            return this.help.call(this);
+        const defaultOptions = this.defaultOptions();
+        this.parser = new this.CommandParserClass(this.signature, this.helperDefinitions, defaultOptions, ...args);
+        for (const option of defaultOptions) {
+            if (this.parser.option(option.option)) {
+                const code = await option.handler.call(this);
+                if (code && code !== 0) {
+                    return code;
+                }
+            }
         }
         this.parser.validate();
         return (await this.handle()) ?? 0;

package/dist/CommandParser.d.ts

@@ -1,3 +1,4 @@
+import { CommandOption } from "./contracts/CommandOption";
 export type ArgSignature = {
     name: string;
     type: string;
@@ -5,7 +6,7 @@ export type ArgSignature = {
     variadic?: boolean;
     alias?: string[];
     help?: string;
-    defaultValue?: string | boolean | Array<string> | null;
+    defaultValue: string | boolean | Array<string> | null;
     isOption?: boolean;
 };
 export declare class CommandParser {
@@ -13,13 +14,16 @@ export declare class CommandParser {
     protected readonly helperDefinitions: {
         [key: string]: string;
     };
-    protected readonly defaultOptions: ArgSignature[];
+    protected readonly defaultCommandOptions: CommandOption<any>[];
     command: string;
     private arguments;
     private options;
     private argumentsSignature;
     private optionSignatures;
     private optionAliases;
+    constructor(signature: string, helperDefinitions: {
+        [key: string]: string;
+    }, defaultCommandOptions: CommandOption<any>[], ...args: any[]);
     option(name: string): any;
     setOption(name: string, value: any): void;
     optionHelp(name: string): string | undefined;
@@ -32,9 +36,6 @@ export declare class CommandParser {
     getOptionSignatures(): {
         [option: string]: ArgSignature;
     };
-    constructor(signature: string, helperDefinitions: {
-        [key: string]: string;
-    }, defaultOptions?: ArgSignature[], ...args: any[]);
     private getParamValue;
     private handleArguments;
     private handleOptions;

package/dist/CommandParser.js

@@ -12,13 +12,25 @@ const InvalidOption_1 = require("./errors/InvalidOption");
 class CommandParser {
     signature;
     helperDefinitions;
-    defaultOptions;
+    defaultCommandOptions;
     command;
     arguments = {};
     options = {};
     argumentsSignature = {};
     optionSignatures = {};
     optionAliases = {};
+    constructor(signature, helperDefinitions, defaultCommandOptions, ...args) {
+        this.signature = signature;
+        this.helperDefinitions = helperDefinitions;
+        this.defaultCommandOptions = defaultCommandOptions;
+        const [command, ...signatureParams] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
+        const { _: paramValues, ...optionValues } = (0, minimist_1.default)(args);
+        this.command = command;
+        this.parseSignature(signatureParams);
+        this.parseDefaultOptions();
+        this.handleArguments(paramValues);
+        this.handleOptions(optionValues);
+    }
     option(name) {
         if (!this.optionSignatures[name]) {
             throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
@@ -63,18 +75,6 @@ class CommandParser {
     getOptionSignatures() {
         return this.optionSignatures;
     }
-    constructor(signature, helperDefinitions, defaultOptions = [], ...args) {
-        this.signature = signature;
-        this.helperDefinitions = helperDefinitions;
-        this.defaultOptions = defaultOptions;
-        const [command, ...signatureParams] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
-        const { _: paramValues, ...optionValues } = (0, minimist_1.default)(args);
-        this.command = command;
-        this.parseSignature(signatureParams);
-        this.parseDefaultOptions();
-        this.handleArguments(paramValues);
-        this.handleOptions(optionValues);
-    }
     getParamValue(value, signature) {
         if (signature.type === 'boolean') {
             if (value === 'true' || value === '1') {
@@ -137,13 +137,22 @@ class CommandParser {
         }
     }
     parseDefaultOptions() {
-        if (this.defaultOptions.length) {
-            for (const option of this.defaultOptions) {
-                this.optionSignatures[option.name] = option;
-                this.options[option.name] = option.defaultValue;
+        if (this.defaultCommandOptions.length) {
+            for (const option of this.defaultCommandOptions) {
+                this.optionSignatures[option.option] = {
+                    name: option.option,
+                    type: option.defaultValue == null ? 'string' : typeof option.defaultValue,
+                    optional: true,
+                    alias: option.alias,
+                    variadic: false,
+                    help: option.description,
+                    defaultValue: option.defaultValue ?? null,
+                    isOption: true
+                };
+                this.options[option.option] = option.defaultValue;
                 if (option.alias) {
                     for (const alias of option.alias) {
-                        this.optionAliases[alias] = option.name;
+                        this.optionAliases[alias] = option.option;
                     }
                 }
             }

package/dist/CommandParser.test.js

@@ -2,10 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const CommandParser_1 = require("./CommandParser");
 const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
+class TestCommandOptions {
+    option = 'testOption';
+    description = 'Test option';
+    defaultValue = 'default';
+    alias = ['t'];
+    async handler() {
+        return 0;
+    }
+}
 describe('CommandParser', () => {
     let commandParser;
-    const parseCommand = (signature, args, helperDefinition = {}) => {
-        return new CommandParser_1.CommandParser(signature, helperDefinition, [], ...args);
+    const parseCommand = (signature, args, helperDefinition = {}, defaultCommandOptions = []) => {
+        return new CommandParser_1.CommandParser(signature, helperDefinition, defaultCommandOptions, ...args);
     };
     it('should parse signature without arguments & options', () => {
         commandParser = parseCommand('test', []);
@@ -141,4 +150,28 @@ describe('CommandParser', () => {
             expect(commandParser.optionHelp('option')).toBe('option help');
         });
     });
+    describe('DefaultCommandOptions', () => {
+        it('should parse default command options', () => {
+            commandParser = parseCommand('test', [], {}, [new TestCommandOptions()]);
+            expect(commandParser.option('testOption')).toBe('default');
+        });
+        it('should parse default command options with provided value', () => {
+            commandParser = parseCommand('test', ['--testOption=value'], {}, [new TestCommandOptions()]);
+            expect(commandParser.option('testOption')).toBe('value');
+        });
+        it('should parse default command options with provided value with alias', () => {
+            commandParser = parseCommand('test', ['-t=value'], {}, [new TestCommandOptions()]);
+            expect(commandParser.option('testOption')).toBe('value');
+        });
+        it('should parse default command option help', () => {
+            commandParser = parseCommand('test', [], {}, [new TestCommandOptions()]);
+            expect(commandParser.optionHelp('testOption')).toBe('Test option');
+        });
+        it('should handle null default value', () => {
+            const option = new TestCommandOptions();
+            option.defaultValue = null;
+            commandParser = parseCommand('test', ['--testOption=value'], {}, [option]);
+            expect(commandParser.option('testOption')).toBe('value');
+        });
+    });
 });

package/dist/commands/HelpCommand.d.ts

@@ -1,9 +1,14 @@
 import { Command } from "../Command";
 import { CommandRegistry } from "../CommandRegistry";
+export type HelpCommandOptions = {
+    commandRegistry: CommandRegistry;
+    cliName?: string;
+    cliVersion?: string;
+};
 export default class HelpCommand extends Command {
-    private commandRegistry;
+    private opts;
     signature: string;
     description: string;
-    constructor(commandRegistry: CommandRegistry);
+    constructor(opts: HelpCommandOptions);
     protected handle(): Promise<void>;
 }

package/dist/commands/HelpCommand.js

@@ -8,17 +8,19 @@ const chalk_1 = __importDefault(require("chalk"));
 const lodash_1 = require("lodash");
 const string_1 = require("../lib/string");
 class HelpCommand extends Command_1.Command {
-    commandRegistry;
+    opts;
     signature = 'help';
     description = 'Show help';
-    constructor(commandRegistry) {
+    constructor(opts) {
         super();
-        this.commandRegistry = commandRegistry;
+        this.opts = opts;
     }
     async handle() {
-        const commands = this.commandRegistry.getCommands();
-        const version = require('../../package.json').version;
-        console.log((0, chalk_1.default) `Bob CLI {green ${version}} 💪
+        const commands = this.opts.commandRegistry.getCommands();
+        const cliName = this.opts.cliName ?? 'Bob CLI';
+        const version = this.opts.cliVersion ?? '0.0.0';
+        const coreVersion = require('../../package.json').version;
+        console.log((0, chalk_1.default) `${cliName} {green ${version}} (core: {yellow ${coreVersion}})
 
 {yellow Usage}:
   command [options] [arguments]

package/dist/contracts/CommandOption.d.ts

@@ -0,0 +1,7 @@
+export interface CommandOption<C> {
+    option: string;
+    alias?: string[];
+    defaultValue: string | boolean | Array<string> | null;
+    description?: string;
+    handler(this: C): Promise<number | void>;
+}

package/dist/contracts/CommandOption.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/index.d.ts

@@ -0,0 +1 @@
+export * from './CommandOption';

package/dist/contracts/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CommandOption"), exports);

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export * from './Command';
 export * from './Cli';
 export * from './errors';
+export * from './contracts';
+export * from './options';

package/dist/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Command"), exports);
 __exportStar(require("./Cli"), exports);
 __exportStar(require("./errors"), exports);
+__exportStar(require("./contracts"), exports);
+__exportStar(require("./options"), exports);

package/dist/options/HelpOption.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "../Command";
+import { CommandOption } from "../contracts/CommandOption";
+export declare class HelpOption implements CommandOption<Command> {
+    option: string;
+    alias: string[];
+    defaultValue: boolean;
+    description: string;
+    handler(this: Command): Promise<number | void>;
+}

package/dist/options/HelpOption.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpOption = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const lodash_1 = require("lodash");
+const string_1 = require("../lib/string");
+class HelpOption {
+    option = 'help';
+    alias = ['h'];
+    defaultValue = false;
+    description = (0, chalk_1.default) `Display help for the given command. When no command is given display help for the {green list} command`;
+    async handler() {
+        const log = console.log;
+        const availableArguments = Object.values(this.parser.getArgumentSignatures());
+        const availableOptions = Object.values(this.parser.getOptionSignatures())
+            .map((signature) => ({
+            ...signature,
+            optionWithAlias: `--${signature.name}${signature.alias?.map(a => `, -${a}`).join('') ?? ''}`
+        }));
+        const requiredArguments = availableArguments.filter((signature) => !signature.optional);
+        log((0, chalk_1.default) `{yellow Description}:`);
+        log((0, chalk_1.default) `  ${this.description}\n`);
+        log((0, chalk_1.default) `{yellow Usage}:`);
+        log((0, chalk_1.default) `  ${this.command} ${requiredArguments.length > 0 ? requiredArguments.map((signature) => `<${signature.name}>`).join(' ') : '\b'} [options]`);
+        const maxOptionLength = (0, lodash_1.max)(availableOptions.map((signature) => signature.optionWithAlias.length)) ?? 0;
+        const maxArgumentLength = (0, lodash_1.max)(availableArguments.map((arg) => arg.name.length)) ?? 0;
+        const maxLength = maxArgumentLength > maxOptionLength ? maxArgumentLength : maxOptionLength;
+        if (availableArguments.length > 0) {
+            log((0, chalk_1.default) `\n{yellow Arguments}:`);
+            for (const signature of availableArguments) {
+                const spaces = (0, string_1.generateSpace)(maxLength - signature.name.length);
+                let message = (0, chalk_1.default) `  {green ${signature.name}} ${spaces} ${signature.help ?? '\b'}`;
+                if (signature.defaultValue !== undefined && signature.optional) {
+                    const defaultValue = signature.type === 'array' ? JSON.stringify(signature.defaultValue) : signature.defaultValue;
+                    message += (0, chalk_1.default) ` {yellow [default: ${defaultValue}]}`;
+                }
+                if (signature.variadic) {
+                    message += (0, chalk_1.default) ` {white (variadic)}`;
+                }
+                log(message);
+            }
+        }
+        if (availableOptions.length > 0) {
+            log((0, chalk_1.default) `\n{yellow Options}:`);
+            for (const signature of availableOptions) {
+                const spaces = (0, string_1.generateSpace)(maxLength - signature.optionWithAlias.length);
+                let message = (0, chalk_1.default) `{green ${signature.optionWithAlias}} ${spaces} ${signature.help ?? '\b'}`;
+                if (signature.type) {
+                    message += (0, chalk_1.default) ` {white (${signature.type})}`;
+                }
+                if (signature.defaultValue !== undefined && signature.optional) {
+                    const defaultValue = signature.type === 'array' ? JSON.stringify(signature.defaultValue) : signature.defaultValue;
+                    message += (0, chalk_1.default) ` {yellow [default: ${defaultValue}]}`;
+                }
+                log(message);
+            }
+        }
+        if (this.commandsExamples.length > 0) {
+            log((0, chalk_1.default) `\n{yellow Examples}:`);
+            let binaryName = process.argv[0].split('/').pop();
+            if (binaryName === 'node') {
+                binaryName += ' ' + process.argv[1].split('/').pop();
+            }
+            for (const [index, example] of this.commandsExamples.entries()) {
+                if (index > 0) {
+                    log('');
+                }
+                log(`  ${example.description}\n`);
+                log((0, chalk_1.default) `    {green ${binaryName} ${example.command}}`);
+            }
+        }
+        return -1;
+    }
+}
+exports.HelpOption = HelpOption;

package/dist/options/index.d.ts

@@ -0,0 +1 @@
+export * from './HelpOption';

package/dist/options/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HelpOption"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bob-core",
-  "version": "0.9.12",
+  "version": "1.0.1",
   "description": "BOB Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/Parser.d.ts

@@ -1,35 +0,0 @@
-export type ArgSignature = {
-    name: string;
-    type: string;
-    optional?: boolean;
-    variadic?: boolean;
-    alias?: string[];
-    help?: string;
-    defaultValue?: string | boolean | Array<string> | null;
-    isOption?: boolean;
-};
-export declare class Parser {
-    protected readonly signature: string;
-    protected readonly helperDefinitions: {
-        [key: string]: string;
-    };
-    command: string;
-    private arguments;
-    private options;
-    private argumentsSignature;
-    private optionsSignature;
-    option(name: string): any;
-    argument(name: string): any;
-    argumentsSignatures(): {
-        [argument: string]: ArgSignature;
-    };
-    optionsSignatures(): {
-        [option: string]: ArgSignature;
-    };
-    constructor(signature: string, helperDefinitions: {
-        [key: string]: string;
-    }, ...args: any[]);
-    private parseSignature;
-    private parseParamSignature;
-    validate(): void;
-}

package/dist/Parser.js

@@ -1,162 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-const minimist_1 = __importDefault(require("minimist"));
-const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
-class Parser {
-    signature;
-    helperDefinitions;
-    command;
-    arguments = {};
-    options = {};
-    argumentsSignature = {};
-    optionsSignature = {};
-    option(name) {
-        if (!this.optionsSignature[name]) {
-            throw new Error(`Option ${name} not found`);
-        }
-        const signature = this.optionsSignature[name];
-        if (signature.type === 'boolean') {
-            if (this.options[name] === 'true' || this.options[name] === '1') {
-                return true;
-            }
-            else if (this.options[name] === 'false' || this.options[name] === '0') {
-                return false;
-            }
-            return Boolean(this.options[name]);
-        }
-        if (signature.type === 'array') {
-            if (!this.options[name]) {
-                return [];
-            }
-            return Array.isArray(this.options[name]) ? this.options[name] : [this.options[name]];
-        }
-        return this.options[name];
-    }
-    argument(name) {
-        return this.arguments[name];
-    }
-    argumentsSignatures() {
-        return this.argumentsSignature;
-    }
-    optionsSignatures() {
-        return this.optionsSignature;
-    }
-    constructor(signature, helperDefinitions, ...args) {
-        this.signature = signature;
-        this.helperDefinitions = helperDefinitions;
-        const [command, ...params] = signature.split(/\{(.*?)\}/g).map(param => param.trim()).filter(Boolean);
-        const { _: paramValues, ...optionValues } = (0, minimist_1.default)(args);
-        this.command = command;
-        this.parseSignature(params, optionValues, paramValues);
-    }
-    parseSignature(params, optionValues, paramValues) {
-        for (const paramSignature of params) {
-            const param = this.parseParamSignature(paramSignature);
-            if (param.isOption) {
-                const optionValue = optionValues[param.name];
-                this.options[param.name] = optionValue ?? param.defaultValue ?? null;
-                this.optionsSignature[param.name] = param;
-                for (const alias of param.alias ?? []) {
-                    if (optionValues[alias]) {
-                        this.options[param.name] = optionValues[alias];
-                        this.optionsSignature[param.name] = param;
-                    }
-                }
-            }
-            else {
-                if (param.variadic) {
-                    const paramValue = paramValues.splice(0, paramValues.length);
-                    this.arguments[param.name] = paramValue ?? [];
-                }
-                else {
-                    const paramValue = paramValues.shift();
-                    this.arguments[param.name] = paramValue ?? param.defaultValue ?? null;
-                }
-                this.argumentsSignature[param.name] = param;
-            }
-        }
-    }
-    parseParamSignature(argument) {
-        let cleanedArgs = argument;
-        let isOptional = false;
-        let isVariadic = false;
-        if (cleanedArgs.endsWith('?')) {
-            cleanedArgs = cleanedArgs.slice(0, -1);
-            isOptional = true;
-        }
-        if (cleanedArgs.endsWith('*')) {
-            cleanedArgs = cleanedArgs.slice(0, -1);
-            isVariadic = true;
-        }
-        const arg = {
-            name: cleanedArgs,
-            optional: isOptional,
-            type: isVariadic ? 'array' : 'string',
-            help: undefined,
-            defaultValue: isVariadic ? [] : null,
-            variadic: isVariadic,
-            isOption: false
-        };
-        if (arg.name.includes(':')) {
-            const [name, help] = arg.name.split(':');
-            arg.name = name.trim();
-            arg.help = help.trim();
-        }
-        if (arg.name.includes('=')) {
-            const [name, defaultValue] = arg.name.split('=');
-            arg.name = name.trim();
-            arg.defaultValue = defaultValue.trim();
-            arg.optional = true;
-            if (!arg.defaultValue.length) {
-                arg.defaultValue = null;
-            }
-            else if (arg.defaultValue === 'true') {
-                arg.defaultValue = true;
-                arg.type = 'boolean';
-            }
-            else if (arg.defaultValue === 'false') {
-                arg.defaultValue = false;
-                arg.type = 'boolean';
-            }
-        }
-        else {
-            if (arg.name.startsWith('--')) {
-                arg.optional = true;
-                arg.defaultValue = false;
-                arg.type = 'boolean';
-            }
-        }
-        if (arg.name.includes('|')) {
-            const [name, ...alias] = arg.name.split('|');
-            arg.name = name.trim();
-            arg.alias = alias.map(a => a.trim());
-        }
-        if (arg.name.startsWith('--')) {
-            arg.isOption = true;
-            arg.name = arg.name.slice(2);
-        }
-        if (arg.defaultValue === '*') {
-            arg.defaultValue = [];
-            arg.type = 'array';
-        }
-        arg.help = arg.help ?? this.helperDefinitions[arg.name] ?? this.helperDefinitions[`--${arg.name}`];
-        return arg;
-    }
-    validate() {
-        // validate arguments
-        for (const [argument, value] of Object.entries(this.arguments)) {
-            const argSignature = this.argumentsSignature[argument];
-            if (!value && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
-            }
-            if (!value?.length && argSignature.variadic && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
-            }
-        }
-    }
-}
-exports.Parser = Parser;

package/dist/errors/BadParameter.d.ts

@@ -1,11 +0,0 @@
-import { BobError } from "./BobError";
-export type BadParameterProps = {
-    param: string;
-    value?: string;
-    reason?: string;
-};
-export declare class BadParameter extends BobError {
-    readonly param: BadParameterProps;
-    constructor(param: BadParameterProps);
-    pretty(): void;
-}

package/dist/errors/BadParameter.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BadParameter = void 0;
-const BobError_1 = require("./BobError");
-const chalk_1 = __importDefault(require("chalk"));
-class BadParameter extends BobError_1.BobError {
-    param;
-    constructor(param) {
-        let message = `Argument "${param.param}" value is invalid.`;
-        if (param.reason) {
-            message += ` Reason: ${param.reason}`;
-        }
-        else {
-            message += ` Value: "${param.value}"`;
-        }
-        super(message);
-        this.param = param;
-    }
-    pretty() {
-        const log = console.log;
-        log((0, chalk_1.default) `  {white.bgRed  ERROR } Argument {bold.yellow ${this.param.param}} value is invalid. `);
-        if (this.param.value || this.param.reason) {
-            log('');
-        }
-        if (this.param.value) {
-            log((0, chalk_1.default) `  {blue Value}: ${this.param.value}`);
-        }
-        if (this.param.reason) {
-            log((0, chalk_1.default) `  {yellow Reason}: ${this.param.reason}`);
-        }
-    }
-}
-exports.BadParameter = BadParameter;