bob-core 0.7.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 | 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);
         }
@@ -26,7 +26,7 @@ class Command extends CommandHelper_1.CommandHelper {
     option(key, defaultValue = null) {
         return this.parser.option(key) ?? defaultValue;
     }
-    argument(key, defaultValue) {
+    argument(key, defaultValue = null) {
         return this.parser.argument(key) ?? defaultValue;
     }
 }

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/CommandHelper.js

@@ -39,7 +39,15 @@ class CommandHelper {
             log((0, chalk_1.default) `\n{yellow Arguments}:`);
             for (const signature of availableArguments) {
                 const spaces = (0, string_1.generateSpace)(maxLength - signature.name.length);
-                log((0, chalk_1.default) `  {green ${signature.name}} ${spaces} ${signature.help ?? '\b'} ${signature.defaultValue !== undefined && signature.optional ? (0, chalk_1.default) `{yellow [default: ${signature.defaultValue}]}` : ''}`);
+                let message = (0, chalk_1.default) `  {green ${signature.name}} ${spaces} ${signature.help ?? '\b'}`;
+                if (signature.defaultValue !== undefined && signature.optional) {
+                    const defaultValue = signature.type === 'array' ? JSON.stringify(signature.defaultValue) : signature.defaultValue;
+                    message += (0, chalk_1.default) ` {yellow [default: ${defaultValue}]}`;
+                }
+                if (signature.variadic) {
+                    message += (0, chalk_1.default) ` {white (variadic)}`;
+                }
+                log(message);
             }
         }
         if (availableOptions.length > 0) {
@@ -51,8 +59,8 @@ class CommandHelper {
                     message += (0, chalk_1.default) ` {white (${signature.type})}`;
                 }
                 if (signature.defaultValue !== undefined && signature.optional) {
-                    const value = signature.type === 'array' ? JSON.stringify(signature.defaultValue) : signature.defaultValue;
-                    message += (0, chalk_1.default) ` {yellow [default: ${value}]}`;
+                    const defaultValue = signature.type === 'array' ? JSON.stringify(signature.defaultValue) : signature.defaultValue;
+                    message += (0, chalk_1.default) ` {yellow [default: ${defaultValue}]}`;
                 }
                 log(message);
             }

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/Parser.d.ts

@@ -1,10 +1,11 @@
 export type ArgSignature = {
     name: string;
     type: string;
-    optional: boolean;
+    optional?: boolean;
+    variadic?: boolean;
     alias?: string[];
     help?: string;
-    defaultValue?: string | boolean | Array<any> | null;
+    defaultValue?: string | boolean | Array<string> | null;
     isOption?: boolean;
 };
 export declare class Parser {

package/dist/Parser.js

@@ -29,6 +29,9 @@ class Parser {
             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];
@@ -65,8 +68,14 @@ class Parser {
                 }
             }
             else {
-                const paramValue = paramValues.shift();
-                this.arguments[param.name] = paramValue ?? param.defaultValue ?? null;
+                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;
             }
         }
@@ -74,16 +83,22 @@ class Parser {
     parseParamSignature(argument) {
         let cleanedArgs = argument;
         let isOptional = false;
-        if (argument.endsWith('?')) {
+        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: 'string',
+            type: isVariadic ? 'array' : 'string',
             help: undefined,
-            defaultValue: null,
+            defaultValue: isVariadic ? [] : null,
+            variadic: isVariadic,
             isOption: false
         };
         if (arg.name.includes(':')) {
@@ -110,6 +125,7 @@ class Parser {
         }
         else {
             if (arg.name.startsWith('--')) {
+                arg.optional = true;
                 arg.defaultValue = false;
                 arg.type = 'boolean';
             }
@@ -127,9 +143,7 @@ class Parser {
             arg.defaultValue = [];
             arg.type = 'array';
         }
-        if (this.helperDefinitions[arg.name]) {
-            arg.help = this.helperDefinitions[arg.name];
-        }
+        arg.help = arg.help ?? this.helperDefinitions[arg.name] ?? this.helperDefinitions[`--${arg.name}`];
         return arg;
     }
     validate() {
@@ -139,6 +153,9 @@ class Parser {
             if (!value && !argSignature.optional) {
                 throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
             }
+            if (!value?.length && argSignature.variadic && !argSignature.optional) {
+                throw new MissingRequiredArgumentValue_1.MissingRequiredArgumentValue(argSignature);
+            }
         }
     }
 }

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.7.0",
+  "version": "0.8.1",
   "description": "BOB Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",