bob-core 0.8.0 → 0.8.1

package/dist/Command.d.ts

@@ -1,5 +1,5 @@
 import { CommandHelper } from "./CommandHelper";
-import { Parser } from "./Parser";
+import { CommandParser } from "./CommandParser";
 export type CommandExample = {
     description: string;
     command: string;
@@ -12,10 +12,10 @@ export declare abstract class Command<C = undefined> extends CommandHelper {
         [key: string]: string;
     };
     protected commandsExamples: CommandExample[];
-    protected parser: Parser;
+    protected parser: CommandParser;
     get command(): string;
     protected abstract handle(): Promise<void | number>;
     run(ctx: C, ...args: any[]): Promise<number>;
-    protected option(key: string, defaultValue?: any): string | null;
-    protected argument(key: string, defaultValue?: any): string | Array<string> | null;
+    protected option<T = string | number | boolean | string[] | number[]>(key: string, defaultValue?: T | null): T | null;
+    protected argument<T = string | number | boolean | string[] | number[]>(key: string, defaultValue?: T | null): T | null;
 }

package/dist/Command.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Command = void 0;
 const CommandHelper_1 = require("./CommandHelper");
-const Parser_1 = require("./Parser");
+const CommandParser_1 = require("./CommandParser");
 class Command extends CommandHelper_1.CommandHelper {
     ctx;
     helperDefinitions = {};
@@ -16,7 +16,7 @@ class Command extends CommandHelper_1.CommandHelper {
     }
     async run(ctx, ...args) {
         this.ctx = ctx;
-        this.parser = new Parser_1.Parser(this.signature, this.helperDefinitions, ...args);
+        this.parser = new CommandParser_1.CommandParser(this.signature, this.helperDefinitions, ...args);
         if (args.includes('--help') || args.includes('-h')) {
             return this.help.call(this);
         }

package/dist/CommandHelper.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "./Command";
-import { ArgSignature } from "./Parser";
+import { ArgSignature } from "./CommandParser";
 export declare class CommandHelper {
     get defaultOptions(): ArgSignature[];
     help(this: Command<any>): number;

package/dist/CommandParser.d.ts

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

package/dist/CommandParser.js

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

package/dist/errors/MissingRequiredArgumentValue.d.ts

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

package/package.json

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