bob-core 1.0.1 → 1.2.1

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/{Cli.d.ts → cjs/src/Cli.d.ts}

@@ -1,7 +1,7 @@
-import { CommandRegistry } from "./CommandRegistry";
-import { Command } from "./Command";
-import HelpCommand from "./commands/HelpCommand";
-import { ExceptionHandler } from "./ExceptionHandler";
+import { CommandRegistry } from "./CommandRegistry.js";
+import { Command } from "./Command.js";
+import HelpCommand from "./commands/HelpCommand.js";
+import { ExceptionHandler } from "./ExceptionHandler.js";
 export type CliOptions<C> = {
     ctx?: C;
     name?: string;

package/dist/{Cli.js → cjs/src/Cli.js}

@@ -4,22 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cli = void 0;
-const CommandRegistry_1 = require("./CommandRegistry");
-const HelpCommand_1 = __importDefault(require("./commands/HelpCommand"));
-const ExceptionHandler_1 = require("./ExceptionHandler");
+const CommandRegistry_js_1 = require("./CommandRegistry.js");
+const HelpCommand_js_1 = __importDefault(require("./commands/HelpCommand.js"));
+const ExceptionHandler_js_1 = require("./ExceptionHandler.js");
 class Cli {
     commandRegistry;
     exceptionHandler;
     ctx;
     helpCommand;
     get CommandRegistryClass() {
-        return CommandRegistry_1.CommandRegistry;
+        return CommandRegistry_js_1.CommandRegistry;
     }
     get HelpCommandClass() {
-        return HelpCommand_1.default;
+        return HelpCommand_js_1.default;
     }
     get ExceptionHandlerClass() {
-        return ExceptionHandler_1.ExceptionHandler;
+        return ExceptionHandler_js_1.ExceptionHandler;
     }
     constructor(opts = {}) {
         this.ctx = opts.ctx;

package/dist/{Command.d.ts → cjs/src/Command.d.ts}

@@ -1,5 +1,5 @@
-import { CommandParser } from "./CommandParser";
-import { CommandOption } from "./contracts/CommandOption";
+import { CommandParser } from "./CommandParser.js";
+import { CommandOption } from "./contracts/index.js";
 export type CommandExample = {
     description: string;
     command: string;

package/dist/{Command.js → cjs/src/Command.js}

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
-const CommandParser_1 = require("./CommandParser");
-const HelpOption_1 = require("./options/HelpOption");
+const CommandParser_js_1 = require("./CommandParser.js");
+const index_js_1 = require("./options/index.js");
 class Command {
     ctx;
     helperDefinitions = {};
     commandsExamples = [];
     parser;
     get CommandParserClass() {
-        return CommandParser_1.CommandParser;
+        return CommandParser_js_1.CommandParser;
     }
     defaultOptions() {
-        return [new HelpOption_1.HelpOption];
+        return [new index_js_1.HelpOption];
     }
     get command() {
         if (this.parser) {

package/dist/{Command.test.js → cjs/src/Command.test.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const Command_1 = require("./Command");
-const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
-class MockCommand extends Command_1.Command {
+const Command_js_1 = require("./Command.js");
+const MissingRequiredArgumentValue_js_1 = require("./errors/MissingRequiredArgumentValue.js");
+class MockCommand extends Command_js_1.Command {
     signature = 'mockCommand {argument} {--option}';
     description = 'This is a mock command for testing';
     handle() {
@@ -43,7 +43,7 @@ describe('Command', () => {
         expect(result).toBe(-1);
     });
     it('should throw error if argument is missing', async () => {
-        await expect(command.run(undefined)).rejects.toThrowError(MissingRequiredArgumentValue_1.MissingRequiredArgumentValue);
+        await expect(command.run(undefined)).rejects.toThrowError(MissingRequiredArgumentValue_js_1.MissingRequiredArgumentValue);
     });
     it('should handle command with option', async () => {
         const result = await command.run(undefined, 'value', '--option');

package/dist/{CommandParser.d.ts → cjs/src/CommandParser.d.ts}

@@ -1,4 +1,4 @@
-import { CommandOption } from "./contracts/CommandOption";
+import { CommandOption } from "./contracts/index.js";
 export type ArgSignature = {
     name: string;
     type: string;

package/dist/{CommandParser.js → cjs/src/CommandParser.js}

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandParser = void 0;
 const minimist_1 = __importDefault(require("minimist"));
-const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
-const MissingSignatureOption_1 = require("./errors/MissingSignatureOption");
-const MissingSignatureArgument_1 = require("./errors/MissingSignatureArgument");
-const InvalidOption_1 = require("./errors/InvalidOption");
+const MissingRequiredArgumentValue_js_1 = require("./errors/MissingRequiredArgumentValue.js");
+const MissingSignatureOption_js_1 = require("./errors/MissingSignatureOption.js");
+const MissingSignatureArgument_js_1 = require("./errors/MissingSignatureArgument.js");
+const InvalidOption_js_1 = require("./errors/InvalidOption.js");
 class CommandParser {
     signature;
     helperDefinitions;
@@ -33,39 +33,39 @@ class CommandParser {
     }
     option(name) {
         if (!this.optionSignatures[name]) {
-            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
+            throw new MissingSignatureOption_js_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
         }
         return this.options[name];
     }
     setOption(name, value) {
         if (!this.optionSignatures[name]) {
-            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
+            throw new MissingSignatureOption_js_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
         }
         this.options[name] = value;
     }
     optionHelp(name) {
         const optionSignature = this.optionSignatures[name];
         if (!optionSignature) {
-            throw new MissingSignatureOption_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
+            throw new MissingSignatureOption_js_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
         }
         return this.optionSignatures[name].help;
     }
     argument(name) {
         if (!this.argumentsSignature[name]) {
-            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+            throw new MissingSignatureArgument_js_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
         }
         return this.arguments[name];
     }
     setArgument(name, value) {
         if (!this.argumentsSignature[name]) {
-            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+            throw new MissingSignatureArgument_js_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
         }
         this.arguments[name] = value;
     }
     argumentHelp(name) {
         const argumentSignature = this.argumentsSignature[name];
         if (!argumentSignature) {
-            throw new MissingSignatureArgument_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
+            throw new MissingSignatureArgument_js_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
         }
         return this.argumentsSignature[name].help;
     }
@@ -110,7 +110,7 @@ class CommandParser {
             const optionAlias = this.optionAliases[option];
             const optionSignature = this.optionSignatures[option] ?? this.optionSignatures[optionAlias];
             if (!optionSignature) {
-                throw new InvalidOption_1.InvalidOption(option, Object.values(this.optionSignatures));
+                throw new InvalidOption_js_1.InvalidOption(option, Object.values(this.optionSignatures));
             }
             this.options[option] = this.getParamValue(value, optionSignature);
             for (const alias of optionSignature.alias ?? []) {
@@ -228,10 +228,10 @@ class CommandParser {
         for (const [argument, value] of Object.entries(this.arguments)) {
             const argSignature = this.argumentsSignature[argument];
             if (!value && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
+                throw new MissingRequiredArgumentValue_js_1.MissingRequiredArgumentValue(argSignature);
             }
             if (!value?.length && argSignature.variadic && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
+                throw new MissingRequiredArgumentValue_js_1.MissingRequiredArgumentValue(argSignature);
             }
         }
     }

package/dist/{CommandParser.test.js → cjs/src/CommandParser.test.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const CommandParser_1 = require("./CommandParser");
-const MissingRequiredArgumentValue_1 = require("./errors/MissingRequiredArgumentValue");
+const CommandParser_js_1 = require("./CommandParser.js");
+const MissingRequiredArgumentValue_js_1 = require("./errors/MissingRequiredArgumentValue.js");
 class TestCommandOptions {
     option = 'testOption';
     description = 'Test option';
@@ -14,7 +14,7 @@ class TestCommandOptions {
 describe('CommandParser', () => {
     let commandParser;
     const parseCommand = (signature, args, helperDefinition = {}, defaultCommandOptions = []) => {
-        return new CommandParser_1.CommandParser(signature, helperDefinition, defaultCommandOptions, ...args);
+        return new CommandParser_js_1.CommandParser(signature, helperDefinition, defaultCommandOptions, ...args);
     };
     it('should parse signature without arguments & options', () => {
         commandParser = parseCommand('test', []);
@@ -59,11 +59,11 @@ describe('CommandParser', () => {
         });
         it('calling validate method should throw error when argument is missing', () => {
             commandParser = parseCommand('test {arg1}', []);
-            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue_1.MissingRequiredArgumentValue);
+            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_1.MissingRequiredArgumentValue);
+            expect(() => commandParser.validate()).toThrowError(MissingRequiredArgumentValue_js_1.MissingRequiredArgumentValue);
         });
     });
     describe('Options', () => {

package/dist/{CommandRegistry.d.ts → cjs/src/CommandRegistry.d.ts}

@@ -1,4 +1,4 @@
-import { Command } from "./Command";
+import { Command } from "./Command.js";
 export type CommandResolver = (path: string) => Promise<Command>;
 export declare class CommandRegistry {
     private readonly commands;

package/dist/{CommandRegistry.js → cjs/src/CommandRegistry.js}

@@ -15,23 +15,33 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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 path_1 = __importDefault(require("path"));
 const fs = __importStar(require("node:fs"));
-const CommandNotFoundError_1 = require("./errors/CommandNotFoundError");
+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() {
@@ -45,7 +55,7 @@ class CommandRegistry {
         return Object.values(this.commands);
     }
     commandResolver = async (path) => {
-        const CommandClass = (await import(path)).default;
+        const CommandClass = (await Promise.resolve(`${path}`).then(s => __importStar(require(s)))).default;
         let command;
         if (CommandClass?.default) {
             command = new CommandClass.default();
@@ -105,7 +115,7 @@ class CommandRegistry {
                 return null;
             }
         }
-        throw new CommandNotFoundError_1.CommandNotFoundError(command, similarCommands);
+        throw new CommandNotFoundError_js_1.CommandNotFoundError(command, similarCommands);
     }
     async askRunSimilarCommand(command, commandToAsk) {
         const readline = require('readline').createInterface({

package/dist/{ExceptionHandler.d.ts → cjs/src/ExceptionHandler.d.ts}

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

package/dist/{ExceptionHandler.js → cjs/src/ExceptionHandler.js}

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

package/dist/{commands → cjs/src/commands}/HelpCommand.d.ts

@@ -1,5 +1,5 @@
-import { Command } from "../Command";
-import { CommandRegistry } from "../CommandRegistry";
+import { Command } from "../Command.js";
+import { CommandRegistry } from "../CommandRegistry.js";
 export type HelpCommandOptions = {
     commandRegistry: CommandRegistry;
     cliName?: string;

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

@@ -0,0 +1,90 @@
+"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/index.d.ts

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

package/dist/{contracts → cjs/src/contracts}/index.js

@@ -14,4 +14,4 @@ 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);
+__exportStar(require("./CommandOption.js"), exports);

package/dist/{errors → cjs/src/errors}/BadCommandOption.d.ts

@@ -1,4 +1,4 @@
-import { BobError } from "./BobError";
+import { BobError } from "../errors/BobError.js";
 export type OptionProps = {
     option: string;
     value?: string;

package/dist/{errors → cjs/src/errors}/BadCommandOption.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadCommandOption = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class BadCommandOption extends BobError_1.BobError {
+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.`;

package/dist/{errors → cjs/src/errors}/BadCommandParameter.d.ts

@@ -1,4 +1,4 @@
-import { BobError } from "./BobError";
+import { BobError } from "../errors/BobError.js";
 export type ParameterProps = {
     param: string;
     value?: string;

package/dist/{errors → cjs/src/errors}/BadCommandParameter.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadCommandParameter = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class BadCommandParameter extends BobError_1.BobError {
+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.`;

package/dist/{errors → cjs/src/errors}/CommandNotFoundError.d.ts

@@ -1,4 +1,4 @@
-import { BobError } from "./BobError";
+import { BobError } from "../errors/BobError.js";
 export declare class CommandNotFoundError extends BobError {
     readonly command: string;
     readonly similarCommands: string[];

package/dist/{errors → cjs/src/errors}/CommandNotFoundError.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandNotFoundError = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class CommandNotFoundError extends BobError_1.BobError {
+const BobError_js_1 = require("../errors/BobError.js");
+class CommandNotFoundError extends BobError_js_1.BobError {
     command;
     similarCommands;
     constructor(command, similarCommands) {

package/dist/{errors → cjs/src/errors}/InvalidOption.d.ts

@@ -1,5 +1,5 @@
-import { BobError } from "./BobError";
-import { ArgSignature } from "../CommandParser";
+import { BobError } from "../errors/BobError.js";
+import { ArgSignature } from "../CommandParser.js";
 export declare class InvalidOption extends BobError {
     private option;
     private optionsSignature;

package/dist/{errors → cjs/src/errors}/InvalidOption.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidOption = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class InvalidOption extends BobError_1.BobError {
+const BobError_js_1 = require("../errors/BobError.js");
+class InvalidOption extends BobError_js_1.BobError {
     option;
     optionsSignature;
     constructor(option, optionsSignature) {

package/dist/{errors → cjs/src/errors}/MissingRequiredArgumentValue.d.ts

@@ -1,5 +1,5 @@
-import { BobError } from "./BobError";
-import { ArgSignature } from "../CommandParser";
+import { BobError } from "../errors/BobError.js";
+import { ArgSignature } from "../CommandParser.js";
 export declare class MissingRequiredArgumentValue extends BobError {
     readonly paramSignature: ArgSignature;
     constructor(paramSignature: ArgSignature);

package/dist/{errors → cjs/src/errors}/MissingRequiredArgumentValue.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MissingRequiredArgumentValue = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class MissingRequiredArgumentValue extends BobError_1.BobError {
+const BobError_js_1 = require("../errors/BobError.js");
+class MissingRequiredArgumentValue extends BobError_js_1.BobError {
     paramSignature;
     constructor(paramSignature) {
         super(`Argument "${paramSignature.name}" is required.`);

package/dist/{errors → cjs/src/errors}/MissingSignatureArgument.d.ts

@@ -1,5 +1,5 @@
-import { BobError } from "./BobError";
-import { ArgSignature } from "../CommandParser";
+import { BobError } from "../errors/BobError.js";
+import { ArgSignature } from "../CommandParser.js";
 export declare class MissingSignatureArgument extends BobError {
     private argument;
     private argumentSignatures;

package/dist/{errors → cjs/src/errors}/MissingSignatureArgument.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MissingSignatureArgument = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class MissingSignatureArgument extends BobError_1.BobError {
+const BobError_js_1 = require("../errors/BobError.js");
+class MissingSignatureArgument extends BobError_js_1.BobError {
     argument;
     argumentSignatures;
     constructor(argument, argumentSignatures) {

package/dist/{errors → cjs/src/errors}/MissingSignatureOption.d.ts

@@ -1,5 +1,5 @@
-import { BobError } from "./BobError";
-import { ArgSignature } from "../CommandParser";
+import { BobError } from "../errors/BobError.js";
+import { ArgSignature } from "../CommandParser.js";
 export declare class MissingSignatureOption extends BobError {
     private option;
     private optionsSignature;

package/dist/{errors → cjs/src/errors}/MissingSignatureOption.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MissingSignatureOption = void 0;
-const BobError_1 = require("./BobError");
 const chalk_1 = __importDefault(require("chalk"));
-class MissingSignatureOption extends BobError_1.BobError {
+const BobError_js_1 = require("../errors/BobError.js");
+class MissingSignatureOption extends BobError_js_1.BobError {
     option;
     optionsSignature;
     constructor(option, optionsSignature) {

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

@@ -0,0 +1,3 @@
+export * from './BobError.js';
+export * from './BadCommandParameter.js';
+export * from './BadCommandOption.js';

package/dist/{errors → cjs/src/errors}/index.js

@@ -14,6 +14,6 @@ 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("./BobError"), exports);
-__exportStar(require("./BadCommandParameter"), exports);
-__exportStar(require("./BadCommandOption"), exports);
+__exportStar(require("./BobError.js"), exports);
+__exportStar(require("./BadCommandParameter.js"), exports);
+__exportStar(require("./BadCommandOption.js"), exports);

package/dist/cjs/src/index.d.ts

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

package/dist/{index.js → cjs/src/index.js}

@@ -14,8 +14,8 @@ 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("./Command"), exports);
-__exportStar(require("./Cli"), exports);
-__exportStar(require("./errors"), exports);
-__exportStar(require("./contracts"), exports);
-__exportStar(require("./options"), exports);
+__exportStar(require("./Command.js"), exports);
+__exportStar(require("./Cli.js"), exports);
+__exportStar(require("./errors/index.js"), exports);
+__exportStar(require("./contracts/index.js"), exports);
+__exportStar(require("./options/index.js"), exports);

package/dist/{lib → cjs/src/lib}/string.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSpace = void 0;
+exports.generateSpace = generateSpace;
 function generateSpace(nb) {
     return new Array(nb + 5).join(' ');
 }
-exports.generateSpace = generateSpace;

package/dist/{options → cjs/src/options}/HelpOption.d.ts

@@ -1,5 +1,5 @@
-import { Command } from "../Command";
-import { CommandOption } from "../contracts/CommandOption";
+import { Command } from "../Command.js";
+import { CommandOption } from "../contracts/index.js";
 export declare class HelpOption implements CommandOption<Command> {
     option: string;
     alias: string[];