@noravel/command 1.0.0

package/dist/Parser.d.ts

@@ -0,0 +1,9 @@
+import InputArgument from './Inputs/InputArgument';
+import InputOption from './Inputs/InputOption';
+export default class Parser {
+    static parse(expression: string): [string, InputArgument[], InputOption[]];
+    protected static name(expression: string): string;
+    protected static parseArgument(token: string): InputArgument;
+    protected static parseOption(token: string): InputOption;
+    protected static extractDescription(token: string): [string, string];
+}

package/dist/Parser.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InputArgument_1 = __importDefault(require("./Inputs/InputArgument"));
+const InputOption_1 = __importDefault(require("./Inputs/InputOption"));
+const InputArgument_2 = require("./Contracts/InputArgument");
+const InputOption_2 = require("./Contracts/InputOption");
+class Parser {
+    static parse(expression) {
+        const name = Parser.name(expression);
+        const _options = [];
+        const _arguments = [];
+        [...expression.matchAll(/\{\s*(.*?)\s*\}/g)].forEach(match => {
+            const optionMatch = match[1].match(/^-{2,}(.*)/);
+            if (optionMatch) {
+                _options.push(Parser.parseOption(optionMatch[1]));
+            }
+            else {
+                _arguments.push(Parser.parseArgument(match[1]));
+            }
+        });
+        return [name, _arguments, _options];
+    }
+    static name(expression) {
+        if (!/[^\s]+/.test(expression)) {
+            throw new Error('Unable to determine command name from signature');
+        }
+        return /[^\s]+/.exec(expression)?.[0] ?? '';
+    }
+    static parseArgument(token) {
+        const [name, description] = Parser.extractDescription(token);
+        switch (true) {
+            case name.endsWith('?*'):
+                return new InputArgument_1.default(name.replace(/\?\*$/, ''), InputArgument_2.ARGUMENT_MODE.IS_ARRAY, description);
+            case name.endsWith('*'):
+                return new InputArgument_1.default(name.replace(/\*$/, ''), InputArgument_2.ARGUMENT_MODE.IS_ARRAY | InputArgument_2.ARGUMENT_MODE.REQUIRED, description);
+            case name.endsWith('?'):
+                return new InputArgument_1.default(name.replace(/\?$/, ''), InputArgument_2.ARGUMENT_MODE.OPTIONAL, description);
+            case /(.+)\=\*(.+)/.test(name):
+                let match = /(.+)\=\*(.+)/.exec(name) ?? ['', '', ''];
+                return new InputArgument_1.default(match[1], InputArgument_2.ARGUMENT_MODE.IS_ARRAY, description, match[2].split(/,\s?/));
+            case /(.+)\=(.+)/.test(name):
+                let match2 = /(.+)\=(.+)/.exec(name) ?? ['', '', ''];
+                return new InputArgument_1.default(match2[1], InputArgument_2.ARGUMENT_MODE.OPTIONAL, description, match2[2]);
+            default:
+                return new InputArgument_1.default(name, InputArgument_2.ARGUMENT_MODE.REQUIRED, description);
+        }
+    }
+    static parseOption(token) {
+        let [name, description] = Parser.extractDescription(token);
+        const matches = name.split(/\s*\|\s*/);
+        let shortcut;
+        if (matches.length > 1) {
+            shortcut = matches[0];
+            name = matches[1];
+        }
+        switch (true) {
+            case name.endsWith('='):
+                return new InputOption_1.default(name.replace(/\=$/, ''), shortcut, InputOption_2.OPTION_MODE.OPTIONAL, description);
+            case name.endsWith('=*'):
+                return new InputOption_1.default(name.replace(/\=\*$/, ''), shortcut, InputOption_2.OPTION_MODE.OPTIONAL | InputOption_2.OPTION_MODE.IS_ARRAY, description);
+            case /(.+)\=\*(.+)/.test(name):
+                let match = /(.+)\=\*(.+)/.exec(name) ?? ['', '', ''];
+                return new InputOption_1.default(match[1], shortcut, InputOption_2.OPTION_MODE.OPTIONAL | InputOption_2.OPTION_MODE.IS_ARRAY, description, match[2].split(/,\s?/));
+            case /(.+)\=(.+)/.test(name):
+                let match2 = /(.+)\=(.+)/.exec(name) ?? ['', '', ''];
+                return new InputOption_1.default(match2[1], shortcut, InputOption_2.OPTION_MODE.OPTIONAL, description, match2[2]);
+            default:
+                return new InputOption_1.default(name, shortcut, InputOption_2.OPTION_MODE.NONE, description);
+        }
+    }
+    static extractDescription(token) {
+        const parts = token.trim().split(/\s+:\s+/);
+        return parts.length === 2 ? parts : [token, ''];
+    }
+}
+exports.default = Parser;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import Command from './Command';
+import Kernel from './Kernel';
+import MakerCommand from './MakerCommand';
+import Executor from './Executor';
+export { Command, Executor, Kernel, MakerCommand };

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MakerCommand = exports.Kernel = exports.Executor = exports.Command = void 0;
+const Command_1 = __importDefault(require("./Command"));
+exports.Command = Command_1.default;
+const Kernel_1 = __importDefault(require("./Kernel"));
+exports.Kernel = Kernel_1.default;
+const MakerCommand_1 = __importDefault(require("./MakerCommand"));
+exports.MakerCommand = MakerCommand_1.default;
+const Executor_1 = __importDefault(require("./Executor"));
+exports.Executor = Executor_1.default;

package/dist/src/Command.d.ts

@@ -0,0 +1,23 @@
+import CommandContract from './Contracts/Command';
+import InputDefinition from './Inputs/InputDefinition';
+import OutputMessage from './Outputs/OutputMessage';
+export default abstract class Command implements CommandContract {
+    argv: string[];
+    protected signature: string;
+    protected name: string;
+    protected description: string;
+    protected definition: InputDefinition;
+    protected inputs: {
+        arguments: Record<string, unknown>;
+        options: Record<string, unknown>;
+    };
+    protected output: OutputMessage;
+    constructor(argv: string[]);
+    bootstrap(): this;
+    getName(): string;
+    getDescription(): string;
+    getArgument(name?: string): unknown;
+    getOption(name?: string): unknown;
+    showHelp(): void;
+    abstract handle(): void;
+}

package/dist/src/Command.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Parser_1 = __importDefault(require("./Parser"));
+const Detector_1 = __importDefault(require("./Detector"));
+const InputDefinition_1 = __importDefault(require("./Inputs/InputDefinition"));
+const OutputMessage_1 = __importDefault(require("./Outputs/OutputMessage"));
+const Helper_1 = __importDefault(require("./Outputs/Helper"));
+class Command {
+    argv;
+    signature = '';
+    name = '';
+    description = '';
+    definition;
+    inputs = {
+        arguments: {},
+        options: {},
+    };
+    output;
+    constructor(argv) {
+        this.argv = argv;
+        this.definition = new InputDefinition_1.default();
+        this.output = new OutputMessage_1.default();
+    }
+    bootstrap() {
+        this.signature = this.signature + ' {--h|help : Display help for the given command} {--v|version : Display the version of Noravel Command}';
+        const [name, argumentDefinition, optionDefinition] = Parser_1.default.parse(this.signature);
+        this.name = name;
+        this.definition.setArguments(argumentDefinition);
+        this.definition.setOptions(optionDefinition);
+        const [_arguments, _options] = Detector_1.default.detect(this.argv.slice(1), this.definition);
+        this.inputs.arguments = _arguments;
+        this.inputs.options = _options;
+        return this;
+    }
+    getName() {
+        return this.name;
+    }
+    getDescription() {
+        return this.description;
+    }
+    getArgument(name) {
+        if (!name) {
+            return Object.values(this.inputs.arguments);
+        }
+        return this.inputs.arguments[name];
+    }
+    getOption(name) {
+        if (!name) {
+            return Object.values(this.inputs.options);
+        }
+        return this.inputs.options[name];
+    }
+    showHelp() {
+        const helper = new Helper_1.default();
+        helper.showHelp(this.name, this.description, this.definition);
+    }
+}
+exports.default = Command;

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

@@ -0,0 +1,9 @@
+export default interface Command {
+    bootstrap(): this;
+    getName(): string;
+    getDescription(): string;
+    getArgument(name?: string): unknown;
+    getOption(name?: string): unknown;
+    showHelp(): void;
+    handle(): void;
+}

package/dist/src/Contracts/Command.js

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

package/dist/src/Contracts/InputArgument.d.ts

@@ -0,0 +1,11 @@
+export declare enum ARGUMENT_MODE {
+    REQUIRED = 1,
+    OPTIONAL = 2,
+    IS_ARRAY = 4
+}
+export interface InputArgument {
+    getName(): string;
+    getDescription(): string;
+    isRequired(): boolean;
+    isArray(): boolean;
+}

package/dist/src/Contracts/InputArgument.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARGUMENT_MODE = void 0;
+var ARGUMENT_MODE;
+(function (ARGUMENT_MODE) {
+    ARGUMENT_MODE[ARGUMENT_MODE["REQUIRED"] = 1] = "REQUIRED";
+    ARGUMENT_MODE[ARGUMENT_MODE["OPTIONAL"] = 2] = "OPTIONAL";
+    ARGUMENT_MODE[ARGUMENT_MODE["IS_ARRAY"] = 4] = "IS_ARRAY";
+})(ARGUMENT_MODE || (exports.ARGUMENT_MODE = ARGUMENT_MODE = {}));

package/dist/src/Contracts/InputOption.d.ts

@@ -0,0 +1,12 @@
+export declare enum OPTION_MODE {
+    NONE = 1,
+    REQUIRED = 2,
+    OPTIONAL = 4,
+    IS_ARRAY = 8
+}
+export interface InputOption {
+    getName(): string;
+    getDescription(): string;
+    isRequired(): boolean;
+    isArray(): boolean;
+}

package/dist/src/Contracts/InputOption.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTION_MODE = void 0;
+var OPTION_MODE;
+(function (OPTION_MODE) {
+    OPTION_MODE[OPTION_MODE["NONE"] = 1] = "NONE";
+    OPTION_MODE[OPTION_MODE["REQUIRED"] = 2] = "REQUIRED";
+    OPTION_MODE[OPTION_MODE["OPTIONAL"] = 4] = "OPTIONAL";
+    OPTION_MODE[OPTION_MODE["IS_ARRAY"] = 8] = "IS_ARRAY";
+})(OPTION_MODE || (exports.OPTION_MODE = OPTION_MODE = {}));

package/dist/src/Detector.d.ts

@@ -0,0 +1,4 @@
+import InputDefinition from './Inputs/InputDefinition';
+export default class Detector {
+    static detect(argv: string[], definition: InputDefinition): [Record<string, any>, Record<string, any>];
+}

package/dist/src/Detector.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Detector {
+    static detect(argv, definition) {
+        const _arguments = {};
+        const _options = {};
+        let i = 0;
+        const argumentDefinitions = definition.getArguments();
+        while (i < argv.length) {
+            if (argv[i].startsWith('-')) {
+                let [key, value] = argv[i].split('=');
+                const optionDefinition = definition.getOptions(key.replace(/^-{1,2}/, ''));
+                const nextIndex = i + 1;
+                if (!optionDefinition) {
+                    i = nextIndex;
+                    continue;
+                }
+                if (/(.+)\=(.+)/.test(argv[i])) {
+                    if (optionDefinition.isArray()) {
+                        value = [...(_options[optionDefinition.getName()] ?? []), value];
+                    }
+                }
+                else if (argv[nextIndex] === undefined || argv[nextIndex].startsWith('-')) {
+                    i = nextIndex;
+                    if (optionDefinition.acceptValue()) {
+                        value = optionDefinition.getDefault();
+                    }
+                    else {
+                        value = true;
+                    }
+                }
+                else {
+                    i = nextIndex;
+                    value = argv[nextIndex];
+                    if (optionDefinition.isArray()) {
+                        value = [...(_options[optionDefinition.getName()] ?? []), argv[nextIndex]];
+                    }
+                }
+                _options[optionDefinition.getName()] = value;
+            }
+            else {
+                const argumentDefinition = argumentDefinitions.shift();
+                _arguments[argumentDefinition?.getName()] = argv[i];
+            }
+            i++;
+        }
+        return [_arguments, _options];
+    }
+}
+exports.default = Detector;

package/dist/src/Inputs/InputArgument.d.ts

@@ -0,0 +1,12 @@
+import { InputArgument as InputArgumentContract } from '../Contracts/InputArgument';
+export default class InputArgument implements InputArgumentContract {
+    name: string;
+    description: string;
+    defaultValue?: string | string[] | undefined;
+    mode: number;
+    constructor(name: string, mode?: number, description?: string, defaultValue?: string | string[] | undefined);
+    getName(): string;
+    getDescription(): string;
+    isRequired(): boolean;
+    isArray(): boolean;
+}

package/dist/src/Inputs/InputArgument.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InputArgument_1 = require("../Contracts/InputArgument");
+class InputArgument {
+    name;
+    description;
+    defaultValue;
+    mode;
+    constructor(name, mode, description = '', defaultValue) {
+        this.name = name;
+        this.description = description;
+        this.defaultValue = defaultValue;
+        if (!mode) {
+            this.mode = InputArgument_1.ARGUMENT_MODE.OPTIONAL;
+        }
+        else if (mode >= 1 && mode <= 7) {
+            this.mode = mode;
+        }
+        else {
+            throw new Error('Invalid argument mode');
+        }
+    }
+    getName() {
+        return this.name;
+    }
+    getDescription() {
+        return this.description;
+    }
+    isRequired() {
+        return (this.mode & InputArgument_1.ARGUMENT_MODE.REQUIRED) === InputArgument_1.ARGUMENT_MODE.REQUIRED;
+    }
+    isArray() {
+        return (this.mode & InputArgument_1.ARGUMENT_MODE.IS_ARRAY) === InputArgument_1.ARGUMENT_MODE.IS_ARRAY;
+    }
+}
+exports.default = InputArgument;

package/dist/src/Inputs/InputDefinition.d.ts

@@ -0,0 +1,11 @@
+import InputArgument from './InputArgument';
+import InputOption from './InputOption';
+export default class InputDefinition {
+    _arguments: InputArgument[];
+    _options: InputOption[];
+    constructor();
+    setArguments(data: InputArgument[]): void;
+    getArguments(): InputArgument[];
+    setOptions(data: InputOption[]): void;
+    getOptions(name?: string): InputOption | InputOption[] | undefined;
+}

package/dist/src/Inputs/InputDefinition.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class InputDefinition {
+    _arguments;
+    _options;
+    constructor() {
+        this._arguments = [];
+        this._options = [];
+    }
+    setArguments(data) {
+        this._arguments = data;
+    }
+    getArguments() {
+        return this._arguments;
+    }
+    setOptions(data) {
+        this._options = data;
+    }
+    getOptions(name) {
+        return name
+            ? this._options.find((option) => option.getName() === name || option.getShortcut() === name)
+            : this._options;
+    }
+}
+exports.default = InputDefinition;

package/dist/src/Inputs/InputOption.d.ts

@@ -0,0 +1,18 @@
+import { InputOption as InputOptionContract } from '../Contracts/InputOption';
+export default class InputOption implements InputOptionContract {
+    description: string;
+    name: string;
+    mode: number;
+    shortcut?: string | string[];
+    defaultValue?: string | string[];
+    constructor(name: string, shortcut?: string | string[], mode?: number, description?: string, defaultValue?: string | string[]);
+    getName(): string;
+    getShortcut(): string | string[] | undefined;
+    getDescription(): string;
+    acceptValue(): boolean;
+    isRequired(): boolean;
+    isOptional(): boolean;
+    isArray(): boolean;
+    setDefault(defaultValue?: string | string[]): void;
+    getDefault(): string | string[] | undefined;
+}

package/dist/src/Inputs/InputOption.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InputOption_1 = require("../Contracts/InputOption");
+class InputOption {
+    description;
+    name;
+    mode;
+    shortcut;
+    defaultValue;
+    constructor(name, shortcut, mode, description = '', defaultValue) {
+        this.description = description;
+        if (name.startsWith('--')) {
+            name = name.substring(2);
+        }
+        if (name == '') {
+            throw new Error('An option name cannot be empty.');
+        }
+        if (shortcut === '' || (Array.isArray(shortcut) && shortcut.length === 0)) {
+            shortcut = undefined;
+        }
+        if (shortcut) {
+            if (Array.isArray(shortcut)) {
+                shortcut = shortcut.join('|');
+            }
+            const shortcuts = shortcut
+                .replace(/^\-/, '')
+                .split(/(\|)-?/)
+                .filter(item => item.length > 0);
+            shortcut = shortcuts.join('|');
+            if (shortcut === '') {
+                throw new Error('An option shortcut cannot be empty.');
+            }
+        }
+        if (!mode) {
+            mode = InputOption_1.OPTION_MODE.NONE;
+        }
+        else if (mode >= InputOption_1.OPTION_MODE.IS_ARRAY << 1 || mode < 1) {
+            throw new Error('Invalid option mode');
+        }
+        this.name = name;
+        this.shortcut = shortcut;
+        this.mode = mode;
+        this.setDefault(defaultValue);
+    }
+    getName() {
+        return this.name;
+    }
+    getShortcut() {
+        return this.shortcut;
+    }
+    getDescription() {
+        return this.description;
+    }
+    acceptValue() {
+        return this.isRequired() || this.isOptional();
+    }
+    isRequired() {
+        return (this.mode & InputOption_1.OPTION_MODE.REQUIRED) === InputOption_1.OPTION_MODE.REQUIRED;
+    }
+    isOptional() {
+        return (this.mode & InputOption_1.OPTION_MODE.OPTIONAL) === InputOption_1.OPTION_MODE.OPTIONAL;
+    }
+    isArray() {
+        return (this.mode & InputOption_1.OPTION_MODE.IS_ARRAY) === InputOption_1.OPTION_MODE.IS_ARRAY;
+    }
+    setDefault(defaultValue) {
+        if ((this.mode & InputOption_1.OPTION_MODE.NONE) === InputOption_1.OPTION_MODE.NONE && defaultValue !== undefined) {
+            throw new Error('Cannot set default value when using OPTION_MODE.NONE mode.');
+        }
+        if (this.isArray()) {
+            if (defaultValue === undefined) {
+                this.defaultValue = [];
+            }
+            else if (!Array.isArray(defaultValue)) {
+                throw new Error('A default value for an array option must be an array.');
+            }
+        }
+        this.defaultValue = this.acceptValue() ? defaultValue : undefined;
+    }
+    getDefault() {
+        return this.defaultValue;
+    }
+}
+exports.default = InputOption;

package/dist/src/Kernel.d.ts

@@ -0,0 +1,15 @@
+import CommandContract from './Contracts/Command';
+export default class Kernel {
+    registeredCommands: (new (argv: string[]) => CommandContract)[];
+    argv: string[];
+    name: string;
+    private callbackVersion?;
+    private color;
+    private output;
+    constructor(argv?: string[]);
+    register(commands: (new (argv: string[]) => CommandContract)[]): this;
+    run(): void;
+    setCallbackVersion(callback: () => void): this;
+    showVersion(): void;
+    getVersion(): any;
+}

package/dist/src/Kernel.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const didyoumean2_1 = __importDefault(require("didyoumean2"));
+const Helper_1 = __importDefault(require("./Outputs/Helper"));
+const OutputColor_1 = __importDefault(require("./Outputs/OutputColor"));
+const OutputMessage_1 = __importDefault(require("./Outputs/OutputMessage"));
+class Kernel {
+    registeredCommands = [];
+    argv;
+    name;
+    callbackVersion;
+    color;
+    output;
+    constructor(argv = []) {
+        this.argv = argv.slice(2);
+        this.name = this.argv[0];
+        this.color = OutputColor_1.default;
+        this.output = new OutputMessage_1.default();
+    }
+    register(commands) {
+        this.registeredCommands = [...this.registeredCommands, ...commands];
+        return this;
+    }
+    run() {
+        if (!this.name) {
+            const helper = new Helper_1.default();
+            helper.showHelpForMain(this.registeredCommands.map((command) => new command(this.argv).bootstrap()));
+            return;
+        }
+        let signatures = [];
+        if (['--help', '-h'].includes(this.name)) {
+            const helper = new Helper_1.default();
+            helper.showHelpForMain(this.registeredCommands.map((command) => new command(this.argv).bootstrap()));
+            return;
+        }
+        if (['--version', '-v'].includes(this.name)) {
+            this.showVersion();
+            return;
+        }
+        for (const command of this.registeredCommands) {
+            const commandInstance = new command(this.argv).bootstrap();
+            const commandName = commandInstance.getName();
+            signatures.push(commandName);
+            if (this.name === commandName) {
+                if (commandInstance.getOption('help')) {
+                    commandInstance.showHelp();
+                    return;
+                }
+                if (commandInstance.getOption('version')) {
+                    this.showVersion();
+                    return;
+                }
+                commandInstance.handle();
+                return;
+            }
+        }
+        const suggestions = (0, didyoumean2_1.default)(this.name, signatures);
+        if (suggestions) {
+            this.output.error(`Command "${this.name}" is not defined. Did you mean "${suggestions}"?`);
+            return;
+        }
+        this.output.error(`Command "${this.name}" is not defined. Did you mean one of these?`);
+        signatures.forEach((signature) => this.output.comment(`   ${signature}`));
+    }
+    setCallbackVersion(callback) {
+        this.callbackVersion = callback.bind(this);
+        return this;
+    }
+    showVersion() {
+        if (this.callbackVersion) {
+            this.callbackVersion();
+            return;
+        }
+        console.log('Noravel Command ' + this.color.green(this.getVersion()));
+    }
+    getVersion() {
+        const packageJsonPath = path_1.default.join(__dirname, '../package.json');
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    }
+}
+exports.default = Kernel;

package/dist/src/MakerCommand.d.ts

@@ -0,0 +1,27 @@
+import Command from './Command';
+export default class MakerCommand extends Command {
+    basePath(dirPath?: string): string;
+    fileName(question?: string): Promise<string>;
+    makeFile(fileName: string, dirPath: string): void;
+    /**
+     * Get the message that the file already exists.
+     *
+     * @returns {string}
+     */
+    protected fileAlreadyExists(filePath: string): string;
+    /**
+     * Get the message that the file created successfully.
+     *
+     * @param {string} filePath
+     * @returns {string}
+     */
+    protected fileCreatedSuccessfully(filePath: string): string;
+    /**
+     * Get the content of the file.
+     *
+     * @param {string} fileName
+     * @returns {string}
+     */
+    protected contentFile(fileName: string): string;
+    handle(): Promise<void>;
+}