bob-core 1.2.2 → 1.2.4

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

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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bob-core",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "BOB Core",
   "type": "module",
   "files": [
@@ -8,43 +8,35 @@
   ],
   "exports": {
     ".": {
-      "import": "./dist/esm/src/index.js",
-      "require": "./dist/cjs/src/index.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/cjs/index.d.ts"
-      ]
+      "types": "./dist/types/src/index.d.ts",
+      "import": "./dist/bob-core.js",
+      "require": "./dist/bob-core.cjs"
     }
   },
   "scripts": {
     "start": "node -r @swc-node/register debug/main.ts",
-    "build": "rimraf ./dist && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc --project tsconfig.json --module commonjs --verbatimModuleSyntax false --moduleResolution node10 --outDir ./dist/cjs && tsc-alias -p tsconfig.json --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
-    "build:esm": "tsc --project tsconfig.json --outDir ./dist/esm && tsc-alias -p tsconfig.json --outDir ./dist/esm",
+    "build": "rimraf ./dist && vite build",
     "prepare": "npm run build",
-    "test": "jest"
+    "test": "vitest run"
   },
   "author": "Léo Hubert",
   "license": "ISC",
   "devDependencies": {
     "@swc-node/register": "^1.11.1",
-    "@types/jest": "^29.5.12",
-    "@types/lodash": "^4.17.5",
     "@types/minimist": "^1.2.5",
     "@types/node": "^20.14.5",
+    "@types/prompts": "^2.4.9",
     "@types/string-similarity": "^4.0.2",
-    "jest": "^29.7.0",
     "rimraf": "^6.0.1",
-    "ts-jest": "^29.1.5",
-    "tsc-alias": "^1.8.16",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vite": "^7.1.6",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "chalk": "^4.1.2",
     "minimist": "^1.2.8",
+    "prompts": "^2.4.2",
     "string-similarity": "^4.0.4"
   }
 }

package/dist/cjs/package.json

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

package/dist/cjs/src/Cli.js

@@ -1,66 +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.Cli = void 0;
-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_js_1.CommandRegistry;
-    }
-    get HelpCommandClass() {
-        return HelpCommand_js_1.default;
-    }
-    get ExceptionHandlerClass() {
-        return ExceptionHandler_js_1.ExceptionHandler;
-    }
-    constructor(opts = {}) {
-        this.ctx = opts.ctx;
-        this.commandRegistry = new this.CommandRegistryClass();
-        this.exceptionHandler = new this.ExceptionHandlerClass();
-        this.helpCommand = new this.HelpCommandClass({
-            cliName: opts.name,
-            cliVersion: opts.version,
-            commandRegistry: this.commandRegistry
-        });
-    }
-    setCommandResolver(resolver) {
-        this.commandRegistry.setCommandResolver(resolver);
-    }
-    async withCommands(...commands) {
-        for (const command of commands) {
-            if (typeof command === 'string') {
-                await this.commandRegistry.loadCommandsPath(command);
-            }
-            else {
-                if (typeof command === 'function') {
-                    this.registerCommand(new command());
-                }
-                else {
-                    this.registerCommand(command);
-                }
-            }
-        }
-    }
-    async runCommand(command, ...args) {
-        if (!command) {
-            return await this.runHelpCommand();
-        }
-        return await this.commandRegistry.runCommand(this.ctx, command, ...args)
-            .catch(this.exceptionHandler.handle);
-    }
-    async runHelpCommand() {
-        return await this.runCommand(this.helpCommand);
-    }
-    registerCommand(command) {
-        this.commandRegistry.registerCommand(command);
-    }
-}
-exports.Cli = Cli;

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

@@ -1,34 +0,0 @@
-import { CommandParser } from "./CommandParser.js";
-import { CommandOption } from "./contracts/index.js";
-export type CommandExample = {
-    description: string;
-    command: string;
-};
-export declare abstract class Command<C = any> {
-    abstract signature: string;
-    abstract description: string;
-    protected ctx: C;
-    protected helperDefinitions: {
-        [key: string]: string;
-    };
-    protected commandsExamples: CommandExample[];
-    protected parser: CommandParser;
-    protected abstract handle(): Promise<void | number>;
-    private get CommandParserClass();
-    protected defaultOptions(): CommandOption<Command<C>>[];
-    get command(): string;
-    run(ctx: C, ...args: any[]): Promise<number>;
-    protected setOption(name: string, value: any): void;
-    protected setArgument(name: string, value: any): void;
-    protected option<T = string>(key: string): T | null;
-    protected option<T = string>(key: string, defaultValue: T): NoInfer<T>;
-    protected optionBoolean(key: string, defaultValue?: boolean): boolean;
-    protected optionArray<T = string>(key: string, defaultValue?: Array<T>): Array<NoInfer<T>>;
-    protected optionNumber(key: string): number | null;
-    protected optionNumber(key: string, defaultValue: number): number;
-    protected argument<T = string>(key: string): T | null;
-    protected argument<T = string>(key: string, defaultValue: T): NoInfer<T>;
-    protected argumentArray<T = string>(key: string, defaultValue?: Array<any>): Array<T>;
-    protected argumentBoolean(key: string, defaultValue?: boolean): boolean;
-    protected argumentNumber(key: string, defaultValue?: number | null): number | null;
-}

package/dist/cjs/src/Command.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = void 0;
-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_js_1.CommandParser;
-    }
-    defaultOptions() {
-        return [new index_js_1.HelpOption];
-    }
-    get command() {
-        if (this.parser) {
-            return this.parser.command;
-        }
-        return this.signature.split(' ')[0];
-    }
-    async run(ctx, ...args) {
-        this.ctx = ctx;
-        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;
-    }
-    setOption(name, value) {
-        this.parser.setOption(name, value);
-    }
-    setArgument(name, value) {
-        this.parser.setArgument(name, value);
-    }
-    option(key, defaultValue = null) {
-        return this.parser.option(key) ?? defaultValue;
-    }
-    optionBoolean(key, defaultValue = false) {
-        return this.parser.option(key) ?? defaultValue;
-    }
-    optionArray(key, defaultValue = []) {
-        const values = this.parser.option(key);
-        if (!Array.isArray(values)) {
-            throw new Error(`Option ${key} is not an array`);
-        }
-        if (values.length) {
-            return values;
-        }
-        return defaultValue;
-    }
-    optionNumber(key, defaultValue = null) {
-        const value = this.parser.option(key);
-        if (!value) {
-            return defaultValue;
-        }
-        if (typeof value === 'number') {
-            return value;
-        }
-        return parseInt(value);
-    }
-    argument(key, defaultValue = null) {
-        return this.parser.argument(key) ?? defaultValue;
-    }
-    argumentArray(key, defaultValue = []) {
-        const values = this.parser.argument(key);
-        if (!Array.isArray(values)) {
-            throw new Error(`Argument ${key} is not an array`);
-        }
-        if (values?.length) {
-            return values;
-        }
-        return defaultValue;
-    }
-    argumentBoolean(key, defaultValue = false) {
-        return this.parser.argument(key) ?? defaultValue;
-    }
-    argumentNumber(key, defaultValue = null) {
-        const value = this.parser.argument(key);
-        if (!value) {
-            return defaultValue;
-        }
-        if (typeof value === 'number') {
-            return value;
-        }
-        return parseInt(value);
-    }
-}
-exports.Command = Command;

package/dist/cjs/src/Command.test.d.ts

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

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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() {
-        const opts = this.option('option');
-        const arg = this.argument('argument');
-        if (opts) {
-            return Promise.resolve(11);
-        }
-        if (arg === 'value') {
-            return Promise.resolve(1);
-        }
-        else if (arg) {
-            return Promise.resolve(-1);
-        }
-        return Promise.resolve(0);
-    }
-}
-describe('Command', () => {
-    let command;
-    beforeEach(() => {
-        command = new MockCommand();
-    });
-    it('should have a command', () => {
-        expect(command.command).toBe('mockCommand');
-    });
-    it('should have a signature', () => {
-        expect(command.signature).toBe('mockCommand {argument} {--option}');
-    });
-    it('should have a description', () => {
-        expect(command.description).toBe('This is a mock command for testing');
-    });
-    it('should handle command with argument', async () => {
-        const result = await command.run(undefined, 'value');
-        expect(result).toBe(1);
-    });
-    it('should handle command with argument', async () => {
-        const result = await command.run(undefined, 'badValue');
-        expect(result).toBe(-1);
-    });
-    it('should throw error if argument is missing', async () => {
-        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');
-        expect(result).toBe(11);
-    });
-});

package/dist/cjs/src/CommandParser.js

@@ -1,239 +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.CommandParser = void 0;
-const minimist_1 = __importDefault(require("minimist"));
-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;
-    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_js_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
-        }
-        return this.options[name];
-    }
-    setOption(name, value) {
-        if (!this.optionSignatures[name]) {
-            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_js_1.MissingSignatureOption(name, Object.values(this.optionSignatures));
-        }
-        return this.optionSignatures[name].help;
-    }
-    argument(name) {
-        if (!this.argumentsSignature[name]) {
-            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_js_1.MissingSignatureArgument(name, Object.values(this.argumentsSignature));
-        }
-        this.arguments[name] = value;
-    }
-    argumentHelp(name) {
-        const argumentSignature = this.argumentsSignature[name];
-        if (!argumentSignature) {
-            throw new MissingSignatureArgument_js_1.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_js_1.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_js_1.MissingRequiredArgumentValue(argSignature);
-            }
-            if (!value?.length && argSignature.variadic && !argSignature.optional) {
-                throw new MissingRequiredArgumentValue_js_1.MissingRequiredArgumentValue(argSignature);
-            }
-        }
-    }
-}
-exports.CommandParser = CommandParser;

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

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