bob-core 1.2.2 → 1.2.3

package/dist/esm/src/CommandParser.js

@@ -1,232 +0,0 @@
-import minimist from 'minimist';
-import { MissingRequiredArgumentValue } from "./errors/MissingRequiredArgumentValue.js";
-import { MissingSignatureOption } from "./errors/MissingSignatureOption.js";
-import { MissingSignatureArgument } from "./errors/MissingSignatureArgument.js";
-import { InvalidOption } from "./errors/InvalidOption.js";
-export class CommandParser {
-    signature;
-    helperDefinitions;
-    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 } = minimist(args);
-        this.command = command;
-        this.parseSignature(signatureParams);
-        this.parseDefaultOptions();
-        this.handleArguments(paramValues);
-        this.handleOptions(optionValues);
-    }
-    option(name) {
-        if (!this.optionSignatures[name]) {
-            throw new MissingSignatureOption(name, Object.values(this.optionSignatures));
-        }
-        return this.options[name];
-    }
-    setOption(name, value) {
-        if (!this.optionSignatures[name]) {
-            throw new MissingSignatureOption(name, Object.values(this.optionSignatures));
-        }
-        this.options[name] = value;
-    }
-    optionHelp(name) {
-        const optionSignature = this.optionSignatures[name];
-        if (!optionSignature) {
-            throw new MissingSignatureOption(name, Object.values(this.optionSignatures));
-        }
-        return this.optionSignatures[name].help;
-    }
-    argument(name) {
-        if (!this.argumentsSignature[name]) {
-            throw new MissingSignatureArgument(name, Object.values(this.argumentsSignature));
-        }
-        return this.arguments[name];
-    }
-    setArgument(name, value) {
-        if (!this.argumentsSignature[name]) {
-            throw new MissingSignatureArgument(name, Object.values(this.argumentsSignature));
-        }
-        this.arguments[name] = value;
-    }
-    argumentHelp(name) {
-        const argumentSignature = this.argumentsSignature[name];
-        if (!argumentSignature) {
-            throw new MissingSignatureArgument(name, Object.values(this.argumentsSignature));
-        }
-        return this.argumentsSignature[name].help;
-    }
-    getArgumentSignatures() {
-        return this.argumentsSignature;
-    }
-    getOptionSignatures() {
-        return this.optionSignatures;
-    }
-    getParamValue(value, signature) {
-        if (signature.type === 'boolean') {
-            if (value === 'true' || value === '1') {
-                return true;
-            }
-            else if (value === 'false' || value === '0') {
-                return false;
-            }
-            return Boolean(value);
-        }
-        if (signature.type === 'array') {
-            if (!value) {
-                return [];
-            }
-            return Array.isArray(value) ? value : [value];
-        }
-        return value ?? signature.defaultValue;
-    }
-    handleArguments(paramValues) {
-        for (const [argument, value] of Object.entries(this.arguments)) {
-            const argSignature = this.argumentsSignature[argument];
-            if (argSignature.variadic) {
-                this.arguments[argument] = paramValues;
-            }
-            else {
-                const paramValue = paramValues.shift();
-                this.arguments[argument] = this.getParamValue(paramValue, argSignature);
-            }
-        }
-    }
-    handleOptions(optionValues) {
-        for (const [option, value] of Object.entries(optionValues)) {
-            const optionAlias = this.optionAliases[option];
-            const optionSignature = this.optionSignatures[option] ?? this.optionSignatures[optionAlias];
-            if (!optionSignature) {
-                throw new InvalidOption(option, Object.values(this.optionSignatures));
-            }
-            this.options[option] = this.getParamValue(value, optionSignature);
-            for (const alias of optionSignature.alias ?? []) {
-                if (optionValues[alias]) {
-                    this.options[optionSignature.name] = optionValues[alias];
-                }
-            }
-        }
-    }
-    parseSignature(params) {
-        for (const paramSignature of params) {
-            const param = this.parseParamSignature(paramSignature);
-            if (param.isOption) {
-                this.options[param.name] = param.defaultValue ?? null;
-                this.optionSignatures[param.name] = param;
-                for (const alias of param.alias ?? []) {
-                    this.optionAliases[alias] = param.name;
-                }
-            }
-            else {
-                this.arguments[param.name] = param.defaultValue ?? null;
-                this.argumentsSignature[param.name] = param;
-            }
-        }
-    }
-    parseDefaultOptions() {
-        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.option;
-                    }
-                }
-            }
-        }
-    }
-    parseParamSignature(argument) {
-        const arg = {
-            name: argument,
-            optional: false,
-            type: 'string',
-            help: undefined,
-            defaultValue: null,
-            variadic: false,
-            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';
-        }
-        if (arg.name.endsWith('?')) {
-            arg.optional = true;
-            arg.name = arg.name.slice(0, -1);
-        }
-        if (arg.name.endsWith('*')) {
-            arg.type = 'array';
-            arg.variadic = true;
-            arg.defaultValue = [];
-            arg.name = arg.name.slice(0, -1);
-        }
-        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(argSignature);
-            }
-            if (!value?.length && argSignature.variadic && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue(argSignature);
-            }
-        }
-    }
-}

package/dist/esm/src/CommandParser.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/CommandParser.test.js

@@ -1,175 +0,0 @@
-import { CommandParser } from './CommandParser.js';
-import { MissingRequiredArgumentValue } from "./errors/MissingRequiredArgumentValue.js";
-class TestCommandOptions {
-    option = 'testOption';
-    description = 'Test option';
-    defaultValue = 'default';
-    alias = ['t'];
-    async handler() {
-        return 0;
-    }
-}
-describe('CommandParser', () => {
-    let commandParser;
-    const parseCommand = (signature, args, helperDefinition = {}, defaultCommandOptions = []) => {
-        return new CommandParser(signature, helperDefinition, defaultCommandOptions, ...args);
-    };
-    it('should parse signature without arguments & options', () => {
-        commandParser = parseCommand('test', []);
-        expect(commandParser.command).toBe('test');
-    });
-    describe('Arguments', () => {
-        it('should parse signature with arguments', () => {
-            commandParser = parseCommand('test {arg1} {arg2}', ['value1', 'value2']);
-            expect(commandParser.argument('arg1')).toBe('value1');
-            expect(commandParser.argument('arg2')).toBe('value2');
-        });
-        it('should parse signature with optional arguments', () => {
-            commandParser = parseCommand('test {arg1?} {arg2?}', ['value1']);
-            expect(commandParser.argument('arg1')).toBe('value1');
-            expect(commandParser.argument('arg2')).toBeNull();
-        });
-        it('should parse signature with optional arguments with default value', () => {
-            commandParser = parseCommand('test {arg1?} {arg2=defaultValue1}', ['value1']);
-            expect(commandParser.argument('arg1')).toBe('value1');
-            expect(commandParser.argument('arg2')).toBe('defaultValue1');
-        });
-        it('should parse signature with variadic arguments', () => {
-            commandParser = parseCommand('test {arg1*}', ['value1', 'value2']);
-            expect(commandParser.argument('arg1')).toEqual(['value1', 'value2']);
-        });
-        it('should parse signature with optional variadic arguments', () => {
-            commandParser = parseCommand('test {arg1*?}', ['value1', 'value2']);
-            expect(commandParser.argument('arg1')).toEqual(['value1', 'value2']);
-        });
-        it('should parse signature with optional variadic arguments without value', () => {
-            commandParser = parseCommand('test {arg1*?}', []);
-            expect(commandParser.argument('arg1')).toEqual([]);
-        });
-        it('should set argument value', () => {
-            commandParser = parseCommand('test {arg1}', ['value1']);
-            commandParser.setArgument('arg1', 'newValue');
-            expect(commandParser.argument('arg1')).toBe('newValue');
-        });
-        it('should throw error when argument is missing with setArgument', () => {
-            commandParser = parseCommand('test {arg1}', []);
-            expect(() => commandParser.setArgument('arg2', 'newValue')).toThrowError(Error);
-        });
-        it('calling validate method should throw error when argument is missing', () => {
-            commandParser = parseCommand('test {arg1}', []);
-            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue);
-        });
-        it('calling validate should throw with variadic argument is missing', () => {
-            commandParser = parseCommand('test {arg1*}', []);
-            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue);
-        });
-    });
-    describe('Options', () => {
-        it('boolean option should be false when not provided', () => {
-            commandParser = parseCommand('test {--option}', []);
-            expect(commandParser.option('option')).toBeFalsy();
-        });
-        it('boolean option should be true when provided', () => {
-            commandParser = parseCommand('test {--option}', ['--option']);
-            expect(commandParser.option('option')).toBeTruthy();
-        });
-        it('boolean option should be true when provided with value', () => {
-            commandParser = parseCommand('test {--option}', ['--option=true']);
-            expect(commandParser.option('option')).toBeTruthy();
-        });
-        it('boolean option should be false when provided with value', () => {
-            commandParser = parseCommand('test {--option}', ['--option=false']);
-            expect(commandParser.option('option')).toBeFalsy();
-        });
-        it('string option should be null when not provided', () => {
-            commandParser = parseCommand('test {--option=}', []);
-            expect(commandParser.option('option')).toBeNull();
-        });
-        it('string option should be value when provided', () => {
-            commandParser = parseCommand('test {--option=}', ['--option=value']);
-            expect(commandParser.option('option')).toBe('value');
-        });
-        it('string option should take the default value when not provided', () => {
-            commandParser = parseCommand('test {--option=default}', []);
-            expect(commandParser.option('option')).toBe('default');
-        });
-        it('string option should take the provided value with default value', () => {
-            commandParser = parseCommand('test {--option=default}', ['--option=value']);
-            expect(commandParser.option('option')).toBe('value');
-        });
-        it('array option should be empty when not provided', () => {
-            commandParser = parseCommand('test {--option=*}', []);
-            expect(commandParser.option('option')).toEqual([]);
-        });
-        it('array option should be value when provided', () => {
-            commandParser = parseCommand('test {--option=*}', ['--option=value1', '--option=value2']);
-            expect(commandParser.option('option')).toEqual(['value1', 'value2']);
-        });
-    });
-    describe('Mixed', () => {
-        it('should parse signature with arguments and options', () => {
-            commandParser = parseCommand('test {arg1} {arg2} {--option}', ['value1', 'value2', '--option']);
-            expect(commandParser.argument('arg1')).toBe('value1');
-            expect(commandParser.argument('arg2')).toBe('value2');
-            expect(commandParser.option('option')).toBeTruthy();
-        });
-        it('should parse signature with optional arguments and options', () => {
-            commandParser = parseCommand('test {arg1?} {arg2?} {--option}', ['value1', '--option']);
-            expect(commandParser.argument('arg1')).toBe('value1');
-            expect(commandParser.argument('arg2')).toBeNull();
-            expect(commandParser.option('option')).toBeTruthy();
-        });
-    });
-    describe('Helper', () => {
-        it('should parse help signature', () => {
-            commandParser = parseCommand('test {arg1} {arg2:help 1} {--option : option help 2 }', ['value1', 'value2', '--option']);
-            expect(commandParser.argumentHelp('arg1')).toBeUndefined();
-            expect(commandParser.argumentHelp('arg2')).toBe('help 1');
-            expect(commandParser.optionHelp('option')).toBe('option help 2');
-        });
-        it('should define help with helperDefinition', () => {
-            commandParser = parseCommand('test {arg1} {arg2} {--option} {--option2}', ['value1', 'value2', '--option'], {
-                arg1: 'arg1 help',
-                arg2: 'arg2 help',
-                '--option': 'option help'
-            });
-            expect(commandParser.argumentHelp('arg1')).toBe('arg1 help');
-            expect(commandParser.argumentHelp('arg2')).toBe('arg2 help');
-            expect(commandParser.optionHelp('option')).toBe('option help');
-            expect(commandParser.optionHelp('option2')).toBeUndefined();
-        });
-        it('should define help with helperDefinition with default value', () => {
-            commandParser = parseCommand('test {arg1:arg1 help} {arg2} {--option=default}', ['value1', 'value2'], {
-                arg2: 'arg2 help',
-                '--option': 'option help'
-            });
-            expect(commandParser.argumentHelp('arg1')).toBe('arg1 help');
-            expect(commandParser.argumentHelp('arg2')).toBe('arg2 help');
-            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/esm/src/CommandRegistry.d.ts

@@ -1,17 +0,0 @@
-import { Command } from "./Command.js";
-export type CommandResolver = (path: string) => Promise<Command>;
-export declare class CommandRegistry {
-    private readonly commands;
-    get commandSuffix(): string;
-    constructor();
-    getAvailableCommands(): string[];
-    getCommands(): Command[];
-    private commandResolver;
-    setCommandResolver(resolver: (path: string) => Promise<Command>): void;
-    registerCommand(command: Command, force?: boolean): void;
-    loadCommandsPath(commandsPath: string): Promise<void>;
-    runCommand(ctx: any, command: string | Command, ...args: any[]): Promise<number>;
-    private suggestCommand;
-    private askRunSimilarCommand;
-    private listCommandsFiles;
-}

package/dist/esm/src/CommandRegistry.js

@@ -1,109 +0,0 @@
-import * as fs from "node:fs";
-import path from "path";
-import * as SS from "string-similarity";
-import chalk from "chalk";
-import { CommandNotFoundError } from "./errors/CommandNotFoundError.js";
-export class CommandRegistry {
-    commands = {};
-    get commandSuffix() {
-        return "Command";
-    }
-    constructor() { }
-    getAvailableCommands() {
-        return Object.keys(this.commands);
-    }
-    getCommands() {
-        return Object.values(this.commands);
-    }
-    commandResolver = async (path) => {
-        const CommandClass = (await import(path)).default;
-        let command;
-        if (CommandClass?.default) {
-            command = new CommandClass.default();
-        }
-        else {
-            command = new CommandClass();
-        }
-        return command;
-    };
-    setCommandResolver(resolver) {
-        this.commandResolver = resolver;
-    }
-    registerCommand(command, force = false) {
-        const commandName = command.signature.split(' ')[0];
-        if (!commandName) {
-            throw new Error('Command signature is invalid, it must have a command name.');
-        }
-        if (!force && this.commands[commandName]) {
-            throw new Error(`Command ${commandName} already registered.`);
-        }
-        this.commands[commandName] = command;
-    }
-    async loadCommandsPath(commandsPath) {
-        for await (const file of this.listCommandsFiles(commandsPath)) {
-            try {
-                const command = await this.commandResolver(file);
-                this.registerCommand(command);
-            }
-            catch (e) {
-                throw new Error(`Command ${file} failed to load. ${e}`);
-            }
-        }
-    }
-    async runCommand(ctx, command, ...args) {
-        const commandToRun = typeof command === 'string' ? this.commands[command] : command;
-        const commandSignature = typeof command === 'string' ? command : commandToRun.command;
-        if (!commandToRun) {
-            const suggestedCommand = await this.suggestCommand(commandSignature);
-            if (suggestedCommand) {
-                return await this.runCommand(ctx, suggestedCommand, ...args);
-            }
-            return 1;
-        }
-        return await commandToRun.run(ctx, ...args);
-    }
-    async suggestCommand(command) {
-        const availableCommands = this.getAvailableCommands();
-        const { bestMatch, bestMatchIndex, ratings } = SS.findBestMatch(command, availableCommands);
-        const similarCommands = ratings.filter(r => r.rating > 0.3).map(r => r.target);
-        if ((bestMatch.rating > 0 && similarCommands.length <= 1) || (bestMatch.rating > 0.7 && similarCommands.length > 1)) {
-            const commandToAsk = availableCommands[bestMatchIndex];
-            const runCommand = await this.askRunSimilarCommand(command, commandToAsk);
-            if (runCommand) {
-                return commandToAsk;
-            }
-            else {
-                return null;
-            }
-        }
-        throw new CommandNotFoundError(command, similarCommands);
-    }
-    async askRunSimilarCommand(command, commandToAsk) {
-        const readline = require('readline').createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        console.log(chalk `  {bgRed  ERROR } Command {yellow ${command}} not found.\n`);
-        return new Promise((resolve) => {
-            readline.question(chalk `{green Do you want to run {yellow ${commandToAsk}} instead?} {white (yes/no)} [{yellow no}]\n > `, (answer) => {
-                resolve(answer === 'yes' || answer === 'y');
-                readline.close();
-            });
-        });
-    }
-    async *listCommandsFiles(basePath) {
-        const dirEntry = fs.readdirSync(basePath, { withFileTypes: true });
-        for (const dirent of dirEntry) {
-            const direntPath = path.resolve(basePath, dirent.name);
-            if (dirent.isDirectory()) {
-                yield* this.listCommandsFiles(path.resolve(basePath, dirent.name));
-            }
-            else {
-                if (!direntPath.endsWith(`${this.commandSuffix}.ts`) && !direntPath.endsWith(`${this.commandSuffix}.js`)) {
-                    continue;
-                }
-                yield direntPath;
-            }
-        }
-    }
-}

package/dist/esm/src/ExceptionHandler.d.ts

@@ -1,4 +0,0 @@
-import { BobError } from "./errors/index.js";
-export declare class ExceptionHandler {
-    handle(err: Error | BobError): number;
-}

package/dist/esm/src/ExceptionHandler.js

@@ -1,10 +0,0 @@
-import { BobError } from "./errors/index.js";
-export class ExceptionHandler {
-    handle(err) {
-        if (err instanceof BobError) {
-            err.pretty();
-            return -1;
-        }
-        throw err;
-    }
-}

package/dist/esm/src/commands/HelpCommand.js

@@ -1,51 +0,0 @@
-import chalk from "chalk";
-import { Command } from "../Command.js";
-import { generateSpace } from "../lib/string.js";
-export default class HelpCommand extends Command {
-    opts;
-    signature = 'help';
-    description = 'Show help';
-    constructor(opts) {
-        super();
-        this.opts = opts;
-    }
-    async handle() {
-        const commands = this.opts.commandRegistry.getCommands();
-        const cliName = this.opts.cliName ?? 'Bob CLI';
-        const version = this.opts.cliVersion ?? '0.0.0';
-        const coreVersion = (await import('../../package.json'))?.default?.version ?? '0.0.0';
-        console.log(chalk `${cliName} {green ${version}} (core: {yellow ${coreVersion}})
-
-{yellow Usage}:
-  command [options] [arguments]
-
-{yellow Available commands}:
-`);
-        const maxCommandLength = Math.max(...commands.map(command => command.command.length)) ?? 0;
-        const commandByGroups = {};
-        for (const command of commands) {
-            const commandGroup = command.command.split(':')[0];
-            if (!commandByGroups[commandGroup]) {
-                commandByGroups[commandGroup] = [];
-            }
-            commandByGroups[commandGroup].push(command);
-        }
-        const sortedCommandsByGroups = Object.entries(commandByGroups)
-            .sort(([groupA], [groupB]) => groupA.toLowerCase().localeCompare(groupB.toLowerCase()))
-            .sort(([, commandsA], [, commandsB]) => commandsA.length - commandsB.length);
-        for (const [group, groupCommands] of sortedCommandsByGroups) {
-            const isGrouped = groupCommands.length > 1;
-            if (isGrouped) {
-                console.log(chalk `{yellow ${group}}:`);
-            }
-            const sortedGroupCommands = groupCommands.sort((a, b) => a.command.toLowerCase().localeCompare(b.command.toLowerCase()));
-            for (const command of sortedGroupCommands) {
-                let spaces = generateSpace(maxCommandLength - command.command.length);
-                if (isGrouped) {
-                    spaces = spaces.slice(2);
-                }
-                console.log(chalk `${isGrouped ? '  ' : ''}{green ${command.command}} ${spaces} ${command.description}`);
-            }
-        }
-    }
-}

package/dist/esm/src/contracts/CommandOption.d.ts

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

package/dist/esm/src/contracts/CommandOption.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/contracts/index.d.ts

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

package/dist/esm/src/contracts/index.js

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

package/dist/esm/src/errors/BadCommandOption.js

@@ -1,29 +0,0 @@
-import chalk from "chalk";
-import { BobError } from "../errors/BobError.js";
-export class BadCommandOption extends BobError {
-    param;
-    constructor(param) {
-        let message = `Option "${param.option}" 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(chalk `  {white.bgRed  ERROR } Option {bold.yellow ${this.param.option}} value is invalid. `);
-        if (this.param.value || this.param.reason) {
-            log('');
-        }
-        if (this.param.value) {
-            log(chalk `  {blue Value}: ${this.param.value}`);
-        }
-        if (this.param.reason) {
-            log(chalk `  {yellow Reason}: ${this.param.reason}`);
-        }
-    }
-}

package/dist/esm/src/errors/BadCommandParameter.d.ts

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