bob-core 1.2.2 → 1.2.4

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

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const CommandParser_js_1 = require("./CommandParser.js");
-const MissingRequiredArgumentValue_js_1 = require("./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_js_1.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_js_1.MissingRequiredArgumentValue);
-        });
-        it('calling validate should throw with variadic argument is missing', () => {
-            commandParser = parseCommand('test {arg1*}', []);
-            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue_js_1.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/cjs/src/CommandRegistry.js

@@ -1,149 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandRegistry = void 0;
-const fs = __importStar(require("node:fs"));
-const path_1 = __importDefault(require("path"));
-const SS = __importStar(require("string-similarity"));
-const chalk_1 = __importDefault(require("chalk"));
-const CommandNotFoundError_js_1 = require("./errors/CommandNotFoundError.js");
-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 Promise.resolve(`${path}`).then(s => __importStar(require(s)))).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_js_1.CommandNotFoundError(command, similarCommands);
-    }
-    async askRunSimilarCommand(command, commandToAsk) {
-        const readline = require('readline').createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        console.log((0, chalk_1.default) `  {bgRed  ERROR } Command {yellow ${command}} not found.\n`);
-        return new Promise((resolve) => {
-            readline.question((0, chalk_1.default) `{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_1.default.resolve(basePath, dirent.name);
-            if (dirent.isDirectory()) {
-                yield* this.listCommandsFiles(path_1.default.resolve(basePath, dirent.name));
-            }
-            else {
-                if (!direntPath.endsWith(`${this.commandSuffix}.ts`) && !direntPath.endsWith(`${this.commandSuffix}.js`)) {
-                    continue;
-                }
-                yield direntPath;
-            }
-        }
-    }
-}
-exports.CommandRegistry = CommandRegistry;

package/dist/cjs/src/ExceptionHandler.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExceptionHandler = void 0;
-const index_js_1 = require("./errors/index.js");
-class ExceptionHandler {
-    handle(err) {
-        if (err instanceof index_js_1.BobError) {
-            err.pretty();
-            return -1;
-        }
-        throw err;
-    }
-}
-exports.ExceptionHandler = ExceptionHandler;

package/dist/cjs/src/commands/HelpCommand.d.ts

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

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

@@ -1,90 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
-const Command_js_1 = require("../Command.js");
-const string_js_1 = require("../lib/string.js");
-class HelpCommand extends Command_js_1.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 Promise.resolve().then(() => __importStar(require('../../package.json'))))?.default?.version ?? '0.0.0';
-        console.log((0, chalk_1.default) `${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((0, chalk_1.default) `{yellow ${group}}:`);
-            }
-            const sortedGroupCommands = groupCommands.sort((a, b) => a.command.toLowerCase().localeCompare(b.command.toLowerCase()));
-            for (const command of sortedGroupCommands) {
-                let spaces = (0, string_js_1.generateSpace)(maxCommandLength - command.command.length);
-                if (isGrouped) {
-                    spaces = spaces.slice(2);
-                }
-                console.log((0, chalk_1.default) `${isGrouped ? '  ' : ''}{green ${command.command}} ${spaces} ${command.description}`);
-            }
-        }
-    }
-}
-exports.default = HelpCommand;

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

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

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

@@ -1,17 +0,0 @@
-"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.js"), exports);

package/dist/cjs/src/errors/BadCommandOption.d.ts

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

package/dist/cjs/src/errors/BadCommandOption.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.BadCommandOption = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const BobError_js_1 = require("../errors/BobError.js");
-class BadCommandOption extends BobError_js_1.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((0, chalk_1.default) `  {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((0, chalk_1.default) `  {blue Value}: ${this.param.value}`);
-        }
-        if (this.param.reason) {
-            log((0, chalk_1.default) `  {yellow Reason}: ${this.param.reason}`);
-        }
-    }
-}
-exports.BadCommandOption = BadCommandOption;

package/dist/cjs/src/errors/BadCommandParameter.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.BadCommandParameter = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const BobError_js_1 = require("../errors/BobError.js");
-class BadCommandParameter extends BobError_js_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.BadCommandParameter = BadCommandParameter;

package/dist/cjs/src/errors/BobError.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BobError = void 0;
-class BobError extends Error {
-}
-exports.BobError = BobError;

package/dist/cjs/src/errors/CommandNotFoundError.js

@@ -1,30 +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.CommandNotFoundError = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const BobError_js_1 = require("../errors/BobError.js");
-class CommandNotFoundError extends BobError_js_1.BobError {
-    command;
-    similarCommands;
-    constructor(command, similarCommands) {
-        super(`Command "${command}" not found.`);
-        this.command = command;
-        this.similarCommands = similarCommands;
-    }
-    pretty() {
-        const log = console.log;
-        if (this.similarCommands.length) {
-            log((0, chalk_1.default) `  {white.bgRed  ERROR } Command "${this.command}" not found, Did you mean one of these?`);
-            for (const cmd of this.similarCommands) {
-                log((0, chalk_1.default) `  {gray ⇂ ${cmd}}`);
-            }
-        }
-        else {
-            log((0, chalk_1.default) `  {white.bgRed  ERROR } Command "${this.command}" not found.`);
-        }
-    }
-}
-exports.CommandNotFoundError = CommandNotFoundError;

package/dist/cjs/src/errors/InvalidOption.d.ts

@@ -1,8 +0,0 @@
-import { BobError } from "../errors/BobError.js";
-import { ArgSignature } from "../CommandParser.js";
-export declare class InvalidOption extends BobError {
-    private option;
-    private optionsSignature;
-    constructor(option: string, optionsSignature: ArgSignature[]);
-    pretty(): void;
-}

package/dist/cjs/src/errors/InvalidOption.js

@@ -1,32 +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.InvalidOption = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const BobError_js_1 = require("../errors/BobError.js");
-class InvalidOption extends BobError_js_1.BobError {
-    option;
-    optionsSignature;
-    constructor(option, optionsSignature) {
-        super(`Invalid option ${option} in not recognized`);
-        this.option = option;
-        this.optionsSignature = optionsSignature;
-    }
-    pretty() {
-        const log = console.log;
-        if (this.optionsSignature.length > 0) {
-            log((0, chalk_1.default) `\n{yellow Available options}:`);
-            for (const option of this.optionsSignature) {
-                const type = option.type ? (0, chalk_1.default) `{white (${option.type})}` : '';
-                const nameWithAlias = `--${option.name}${option.alias?.map(a => `, -${a}`).join('') ?? ''}`;
-                const spaces = ' '.repeat(30 - nameWithAlias.length);
-                log((0, chalk_1.default) `  {green ${nameWithAlias}} ${spaces} ${option.help ?? '\b'} ${type}`);
-            }
-            log('');
-        }
-        log((0, chalk_1.default) `  {white.bgRed  ERROR } Option {bold.yellow ${this.option}} is not recognized.`);
-    }
-}
-exports.InvalidOption = InvalidOption;

package/dist/cjs/src/errors/MissingRequiredArgumentValue.js

@@ -1,23 +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.MissingRequiredArgumentValue = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const BobError_js_1 = require("../errors/BobError.js");
-class MissingRequiredArgumentValue extends BobError_js_1.BobError {
-    paramSignature;
-    constructor(paramSignature) {
-        super(`Argument "${paramSignature.name}" is required.`);
-        this.paramSignature = paramSignature;
-    }
-    pretty() {
-        const log = console.log;
-        if (this.paramSignature.help) {
-            log((0, chalk_1.default) `{yellow Help}: ${this.paramSignature.help}\n`);
-        }
-        log((0, chalk_1.default) `  {white.bgRed  ERROR } Argument {bold.yellow ${this.paramSignature.name}} is required.`);
-    }
-}
-exports.MissingRequiredArgumentValue = MissingRequiredArgumentValue;