@noravel/command 1.0.0

package/dist/Contracts/CommandDefinition.d.ts

@@ -0,0 +1,7 @@
+import InputArgument from '../Inputs/InputArgument';
+import InputOption from '../Inputs/InputOption';
+export default interface CommandDefinition {
+    name: string;
+    arguments: InputArgument[];
+    options: InputOption[];
+}

package/dist/Contracts/CommandDefinition.js

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

package/dist/Contracts/InputArgument.d.ts

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

package/dist/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/Contracts/InputOption.d.ts

@@ -0,0 +1,15 @@
+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;
+    acceptValue(): boolean;
+    getShortcut(): string | string[] | undefined;
+    getDefault(): string | string[] | undefined;
+}

package/dist/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/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/Detector.js

@@ -0,0 +1,73 @@
+"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();
+        const optionDefinitions = definition.getOptions();
+        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++;
+        }
+        // Ensure that default values ​​are used for options that do not exist in the argv
+        for (const option of optionDefinitions) {
+            if (_options[option.getName()] === undefined) {
+                if (option.getDefault() !== undefined) {
+                    _options[option.getName()] = option.getDefault();
+                }
+                else if (option.isRequired()) {
+                    throw new Error(`Option ${option.getName()} is required`);
+                }
+            }
+        }
+        // Ensure that default values ​​are used for arguments that do not exist in the argv
+        for (const _argument of argumentDefinitions) {
+            if (_arguments[_argument.getName()] === undefined) {
+                if (_argument.getDefault() !== undefined) {
+                    _arguments[_argument.getName()] = _argument.getDefault();
+                }
+                else if (_argument.isRequired()) {
+                    throw new Error(`Argument ${_argument.getName()} is required`);
+                }
+            }
+        }
+        return [_arguments, _options];
+    }
+}
+exports.default = Detector;

package/dist/Executor.d.ts

@@ -0,0 +1,4 @@
+import Command from './Contracts/Command';
+export default class Executor {
+    static call(command: (new (argv: string[]) => Command), argv: string[]): Promise<void>;
+}

package/dist/Executor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Executor {
+    static async call(command, argv) {
+        const commandInstance = new command(argv).bootstrap();
+        return await commandInstance.handle();
+    }
+}
+exports.default = Executor;

package/dist/Inputs/InputArgument.d.ts

@@ -0,0 +1,13 @@
+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;
+    getDefault(): string | string[] | undefined;
+}

package/dist/Inputs/InputArgument.js

@@ -0,0 +1,39 @@
+"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;
+    }
+    getDefault() {
+        return this.defaultValue;
+    }
+}
+exports.default = InputArgument;

package/dist/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/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/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;
+    private setDefault;
+    getDefault(): string | string[] | undefined;
+}

package/dist/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/Inputs/Prompt.d.ts

@@ -0,0 +1,5 @@
+export default class Prompt {
+    ask(message: string): Promise<string>;
+    secret(message: string): Promise<string>;
+    choice(question: string, options: string[], defaultIndex?: number, allowMultipleSelections?: boolean): Promise<string | string[]>;
+}

package/dist/Inputs/Prompt.js

@@ -0,0 +1,178 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("node:readline"));
+class Prompt {
+    async ask(message) {
+        return new Promise(resolve => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(message + '\n', answer => {
+                rl.close();
+                resolve(answer);
+            });
+        });
+    }
+    async secret(message) {
+        const stdin = process.stdin;
+        if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+            return this.ask(message);
+        }
+        return new Promise((resolve, reject) => {
+            process.stdout.write(message + '\n');
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+            let password = '';
+            const onData = (key) => {
+                if (key === '\r' || key === '\n') {
+                    // Enter
+                    stdin.setRawMode(false);
+                    stdin.pause();
+                    stdin.removeListener('data', onData);
+                    process.stdout.write('\n');
+                    resolve(password);
+                }
+                else if (key === '\u0003') {
+                    // Ctrl+C
+                    process.exit();
+                }
+                else if (key === '\u007f') {
+                    // Backspace
+                    password = password.slice(0, -1);
+                }
+                else {
+                    password += key;
+                }
+            };
+            stdin.on('data', onData);
+        });
+    }
+    choice(question, options, defaultIndex = 0, allowMultipleSelections = false) {
+        return new Promise(resolve => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            let cursor = defaultIndex;
+            let selected = new Set();
+            let done = false;
+            // number of lines already rendered (to know how many lines to move the cursor up)
+            let renderedLines = 0;
+            function getLines() {
+                const lines = [];
+                lines.push(question, '');
+                options.forEach((opt, index) => {
+                    const isCursor = index === cursor;
+                    const isSelected = selected.has(index);
+                    const prefix = isCursor ? '👉' : '  ';
+                    let mark;
+                    if (allowMultipleSelections) {
+                        mark = isSelected ? '[x]' : '[ ]';
+                    }
+                    else {
+                        mark = isCursor ? '(●)' : '( )';
+                    }
+                    lines.push(`${prefix} ${mark} ${opt}`);
+                });
+                lines.push('', allowMultipleSelections ? '(space để chọn, enter để submit)' : '(enter để chọn)');
+                return lines;
+            }
+            function render() {
+                const lines = getLines();
+                // 🧠 move cursor to the beginning of the rendered content
+                if (renderedLines > 0) {
+                    process.stdout.write(`\x1b[${renderedLines}A`);
+                }
+                // 🧹 clear each line and rewrite
+                lines.forEach(line => {
+                    process.stdout.write('\x1b[2K'); // clear line
+                    process.stdout.write(line + '\n');
+                });
+                renderedLines = lines.length;
+            }
+            function cleanup(result) {
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+                process.stdin.removeAllListeners('keypress');
+                process.stdin.unref();
+                resolve(result);
+            }
+            render();
+            const keypressHandler = (_str, key) => {
+                if (done)
+                    return;
+                if (key.name === 'up') {
+                    cursor = (cursor - 1 + options.length) % options.length;
+                }
+                if (key.name === 'down') {
+                    cursor = (cursor + 1) % options.length;
+                }
+                if (allowMultipleSelections && key.name === 'space') {
+                    if (selected.has(cursor)) {
+                        selected.delete(cursor);
+                    }
+                    else {
+                        selected.add(cursor);
+                    }
+                }
+                if (key.name === 'return') {
+                    done = true;
+                    if (allowMultipleSelections) {
+                        const result = Array.from(selected).map(i => options[i]);
+                        cleanup(result);
+                    }
+                    else {
+                        cleanup(options[cursor]);
+                    }
+                    process.stdin.off('keypress', keypressHandler);
+                    return;
+                }
+                if (key.ctrl && key.name === 'c') {
+                    done = true;
+                    cleanup([]);
+                    process.exit();
+                }
+                render();
+            };
+            process.stdin.on('keypress', keypressHandler);
+        });
+    }
+}
+exports.default = Prompt;

package/dist/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/Kernel.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node: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) {
+                commandInstance.detect();
+                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 = node_path_1.default.join(__dirname, '../package.json');
+        const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    }
+}
+exports.default = Kernel;

package/dist/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>;
+}