@noravel/command 1.0.0

package/dist/MakerCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const Command_1 = __importDefault(require("./Command"));
+class MakerCommand extends Command_1.default {
+    basePath(dirPath) {
+        const basePath = process.cwd();
+        if (!dirPath) {
+            return basePath;
+        }
+        dirPath = node_path_1.default.join(basePath, dirPath);
+        if (!node_fs_1.default.existsSync(dirPath)) {
+            node_fs_1.default.mkdirSync(dirPath, { recursive: true });
+        }
+        return dirPath;
+    }
+    async fileName(question = 'What should the file be named?') {
+        let name = this.getArgument('name');
+        if (!name) {
+            name = await this.prompt.ask(question);
+        }
+        return name;
+    }
+    makeFile(fileName, dirPath) {
+        const filePath = node_path_1.default.join(this.basePath(dirPath), `${fileName}.js`);
+        if (node_fs_1.default.existsSync(filePath) && !this.getOption('force')) {
+            this.output.error(this.fileAlreadyExists(filePath));
+            return;
+        }
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+        node_fs_1.default.writeFileSync(filePath, this.contentFile(fileName), 'utf8');
+        this.output.success(this.fileCreatedSuccessfully(filePath));
+    }
+    /**
+     * Get the message that the file already exists.
+     *
+     * @returns {string}
+     */
+    fileAlreadyExists(filePath) {
+        return `File [${filePath}] already exists.`;
+    }
+    /**
+     * Get the message that the file created successfully.
+     *
+     * @param {string} filePath
+     * @returns {string}
+     */
+    fileCreatedSuccessfully(filePath) {
+        return `File [${filePath}] created successfully.`;
+    }
+    /**
+     * Get the content of the file.
+     *
+     * @param {string} fileName
+     * @returns {string}
+     */
+    contentFile(fileName) {
+        return '';
+    }
+    async handle() {
+        //
+    }
+}
+exports.default = MakerCommand;

package/dist/Outputs/Helper.d.ts

@@ -0,0 +1,7 @@
+import Command from '../Contracts/Command';
+import InputDefinition from '../Inputs/InputDefinition';
+export default class Helper {
+    showHelp(name: string, description: string, definition: InputDefinition): void;
+    showHelpForMain(commands: Command[]): void;
+    showExplanation(command: string, explanation: string): string;
+}

package/dist/Outputs/Helper.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 OutputColor_1 = __importDefault(require("./OutputColor"));
+const MAX_LENGTH = 25;
+class Helper {
+    showHelp(name, description, definition) {
+        console.log(OutputColor_1.default.yellow('Description:'));
+        console.log(`  ${description}`);
+        console.log('');
+        const argumentDefinition = definition.getArguments();
+        console.log(OutputColor_1.default.yellow('Usage:'));
+        console.log(`  ${name} [options] [--] ${argumentDefinition.map((argument) => `<${argument.getName()}>`).join(' ')}`);
+        console.log('');
+        if (argumentDefinition.length) {
+            console.log(OutputColor_1.default.yellow('Arguments:'));
+            argumentDefinition.forEach((argument) => {
+                console.log(OutputColor_1.default.green(`  ${argument.getName()} `) +
+                    `${' '.repeat(MAX_LENGTH - argument.getName().length - 2)}${argument.getDescription()}`);
+            });
+            console.log('');
+        }
+        const optionDefinition = definition.getOptions();
+        if (optionDefinition.length) {
+            console.log(OutputColor_1.default.yellow('Options:'));
+            optionDefinition.forEach((option) => {
+                let shortcut = option.getShortcut();
+                if (Array.isArray(shortcut)) {
+                    shortcut = shortcut.map((item) => `-${item}`).join(', ') + ',';
+                }
+                else if (shortcut) {
+                    shortcut = `-${shortcut},`;
+                }
+                else {
+                    shortcut = '   ';
+                }
+                console.log(OutputColor_1.default.green(this.showExplanation(`${shortcut} --${option.getName()}`, option.getDescription())));
+            });
+            console.log('');
+        }
+    }
+    showHelpForMain(commands) {
+        console.log(OutputColor_1.default.yellow('Usage:'));
+        console.log(OutputColor_1.default.green('  command [arguments] [--options]'));
+        console.log('');
+        console.log(OutputColor_1.default.yellow('Available commands:'));
+        commands.forEach((command) => {
+            console.log(OutputColor_1.default.green(this.showExplanation(command.getName(), command.getDescription())));
+        });
+        console.log('');
+        console.log(OutputColor_1.default.yellow('Options:'));
+        console.log(OutputColor_1.default.green(this.showExplanation('-h, --help', 'Show this help message')));
+        console.log(OutputColor_1.default.green(this.showExplanation('-v, --version', 'Display the version of Noravel Command')));
+    }
+    showExplanation(command, explanation) {
+        return `  ${command}${' '.repeat(MAX_LENGTH - command.length - 2)}${explanation}`;
+    }
+}
+exports.default = Helper;

package/dist/Outputs/OutputColor.d.ts

@@ -0,0 +1,18 @@
+export default class OutputColor {
+    static black(message: string): string;
+    static red(message: string): string;
+    static green(message: string): string;
+    static yellow(message: string): string;
+    static blue(message: string): string;
+    static magenta(message: string): string;
+    static cyan(message: string): string;
+    static white(message: string): string;
+    static bgBlack(message: string): string;
+    static bgRed(message: string): string;
+    static bgGreen(message: string): string;
+    static bgYellow(message: string): string;
+    static bgBlue(message: string): string;
+    static bgMagenta(message: string): string;
+    static bgCyan(message: string): string;
+    static bgWhite(message: string): string;
+}

package/dist/Outputs/OutputColor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OutputColor {
+    static black(message) {
+        return `\x1b[30m${message}\x1b[0m`;
+    }
+    static red(message) {
+        return `\x1b[31m${message}\x1b[0m`;
+    }
+    static green(message) {
+        return `\x1b[32m${message}\x1b[0m`;
+    }
+    static yellow(message) {
+        return `\x1b[33m${message}\x1b[0m`;
+    }
+    static blue(message) {
+        return `\x1b[34m${message}\x1b[0m`;
+    }
+    static magenta(message) {
+        return `\x1b[35m${message}\x1b[0m`;
+    }
+    static cyan(message) {
+        return `\x1b[36m${message}\x1b[0m`;
+    }
+    static white(message) {
+        return `\x1b[37m${message}\x1b[0m`;
+    }
+    static bgBlack(message) {
+        return `\x1b[40m${message}\x1b[0m`;
+    }
+    static bgRed(message) {
+        return `\x1b[41m${message}\x1b[0m`;
+    }
+    static bgGreen(message) {
+        return `\x1b[42m${message}\x1b[0m`;
+    }
+    static bgYellow(message) {
+        return `\x1b[43m${message}\x1b[0m`;
+    }
+    static bgBlue(message) {
+        return `\x1b[44m${message}\x1b[0m`;
+    }
+    static bgMagenta(message) {
+        return `\x1b[45m${message}\x1b[0m`;
+    }
+    static bgCyan(message) {
+        return `\x1b[46m${message}\x1b[0m`;
+    }
+    static bgWhite(message) {
+        return `\x1b[47m${message}\x1b[0m`;
+    }
+}
+exports.default = OutputColor;

package/dist/Outputs/OutputMessage.d.ts

@@ -0,0 +1,11 @@
+import ProgressBar from './ProgressBar/ProgressBar';
+export default class OutputMessage {
+    info(message: string): void;
+    error(message: string): void;
+    warning(message: string): void;
+    success(message: string): void;
+    comment(message: string): void;
+    line(message: string, type?: 'line' | 'info' | 'error' | 'warning' | 'success' | 'comment'): void;
+    table(heading: string[], rows: string[][]): void;
+    createProgressBar(total: number, size?: number | null): ProgressBar;
+}

package/dist/Outputs/OutputMessage.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const OutputColor_1 = __importDefault(require("./OutputColor"));
+const ProgressBar_1 = __importDefault(require("./ProgressBar/ProgressBar"));
+class OutputMessage {
+    info(message) {
+        this.line(message, 'info');
+    }
+    error(message) {
+        this.line(message, 'error');
+    }
+    warning(message) {
+        this.line(message, 'warning');
+    }
+    success(message) {
+        this.line(message, 'success');
+    }
+    comment(message) {
+        this.line(message, 'comment');
+    }
+    line(message, type = 'line') {
+        console.log({
+            line: (message) => message,
+            info: OutputColor_1.default.cyan,
+            error: OutputColor_1.default.red,
+            warning: OutputColor_1.default.yellow,
+            success: OutputColor_1.default.green,
+            comment: OutputColor_1.default.white,
+        }[type](message));
+    }
+    table(heading, rows) {
+        const terminalWidth = process.stdout.columns;
+        const widthColumns = heading.map(h => h.length + 3);
+        for (const row of rows) {
+            for (let i = 0; i < row.length; i++) {
+                if (row[i].length + 3 > widthColumns[i]) {
+                    widthColumns[i] = row[i].length + 3;
+                }
+            }
+        }
+        let totalWidthColumns = widthColumns.reduce((total, width) => total + width, 1);
+        if (terminalWidth < totalWidthColumns) {
+            totalWidthColumns = terminalWidth;
+        }
+        let line = '+';
+        let th = '|';
+        for (let i = 0; i < heading.length; i++) {
+            line += '-'.repeat(widthColumns[i] - 1) + '+';
+            th += ' ' + OutputColor_1.default.green(`${heading[i]}`.padEnd(widthColumns[i] - 3)) + ' |';
+        }
+        console.log(line);
+        console.log(th);
+        console.log(line);
+        for (const row of rows) {
+            let tr = '|';
+            for (let i = 0; i < row.length; i++) {
+                tr += ' ' + `${row[i]}`.padEnd(widthColumns[i] - 3) + ' |';
+            }
+            console.log(tr);
+        }
+        console.log(line);
+    }
+    createProgressBar(total, size = null) {
+        return new ProgressBar_1.default(total, size);
+    }
+}
+exports.default = OutputMessage;

package/dist/Outputs/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,22 @@
+export type ProgressBarFormat = 'normal' | 'verbose' | 'minimal';
+export default class ProgressBar {
+    private total;
+    current: number;
+    startTime: number | null;
+    private size;
+    private progressStyle;
+    private format;
+    constructor(total: number, size?: number | null);
+    setTotal(total: number): void;
+    getTotal(): number;
+    setFormat(format: 'normal' | 'verbose' | 'minimal'): void;
+    setSize(size: number): void;
+    getSize(): number;
+    start(message?: string): void;
+    advance(): null | undefined;
+    finish(message?: string): void;
+    private getStatusBar;
+    useShapeProgress(): void;
+    useArrowProgress(): void;
+    useBlockProgress(): void;
+}

package/dist/Outputs/ProgressBar/ProgressBar.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StatusBarFactory_1 = require("./StatusBarFactory");
+const ARROW_PROGRESS_STYLE = {
+    complete: '=',
+    incomplete: '-',
+    head: '>',
+};
+const SHAPE_PROGRESS_STYLE = {
+    complete: '#',
+    incomplete: '_',
+    head: '#',
+};
+const BLOCK_PROGRESS_STYLE = {
+    complete: '█',
+    incomplete: '░',
+    head: '█',
+};
+class ProgressBar {
+    total;
+    current = 0;
+    startTime = null;
+    size;
+    progressStyle = ARROW_PROGRESS_STYLE;
+    format = 'normal';
+    constructor(total, size = null) {
+        this.total = total;
+        this.size = size === null ? process.stdout.columns : size;
+    }
+    setTotal(total) {
+        this.total = total;
+    }
+    getTotal() {
+        return this.total;
+    }
+    setFormat(format) {
+        if (!['normal', 'verbose', 'minimal'].includes(format)) {
+            return;
+        }
+        this.format = format;
+    }
+    setSize(size) {
+        const terminalWidth = process.stdout.columns;
+        if (terminalWidth < size) {
+            this.size = terminalWidth;
+        }
+        else {
+            this.size = size;
+        }
+    }
+    getSize() {
+        return this.size;
+    }
+    start(message = '') {
+        this.current = 0;
+        this.startTime = new Date().getTime() / 1000;
+        console.log(message);
+    }
+    advance() {
+        this.current++;
+        if (this.total < this.current || this.startTime === null) {
+            return null;
+        }
+        process.stdout.write(this.getStatusBar());
+        if (this.current === this.total) {
+            process.stdout.write('\n');
+        }
+    }
+    finish(message = '') {
+        this.current = this.total;
+        console.log(message);
+    }
+    getStatusBar() {
+        const perc = this.current / this.total;
+        if (this.format === 'minimal') {
+            return '\rProgress: ' + (perc * 100).toFixed(1) + '%';
+        }
+        let statusBarInfo = StatusBarFactory_1.StatusBarFactory.create(this.format, this).getInfo(perc);
+        let bar = Math.floor(perc * statusBarInfo.size);
+        let statusBar = statusBarInfo.prefix + this.progressStyle.complete.repeat(bar);
+        if (bar < statusBarInfo.size) {
+            statusBar += this.progressStyle.head;
+            statusBar += this.progressStyle.incomplete.repeat(statusBarInfo.size - bar - 1);
+        }
+        statusBar += statusBarInfo.suffix;
+        return statusBar;
+    }
+    useShapeProgress() {
+        this.progressStyle = SHAPE_PROGRESS_STYLE;
+    }
+    useArrowProgress() {
+        this.progressStyle = ARROW_PROGRESS_STYLE;
+    }
+    useBlockProgress() {
+        this.progressStyle = BLOCK_PROGRESS_STYLE;
+    }
+}
+exports.default = ProgressBar;

package/dist/Outputs/ProgressBar/StatusBar.d.ts

@@ -0,0 +1,11 @@
+import ProgressBar from './ProgressBar';
+export type StatusBarInfo = {
+    prefix: string;
+    suffix: string;
+    size: number;
+};
+export declare abstract class StatusBar {
+    protected progressbar: ProgressBar;
+    constructor(progressbar: ProgressBar);
+    abstract getInfo(perc: number): StatusBarInfo;
+}

package/dist/Outputs/ProgressBar/StatusBar.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusBar = void 0;
+class StatusBar {
+    progressbar;
+    constructor(progressbar) {
+        this.progressbar = progressbar;
+    }
+}
+exports.StatusBar = StatusBar;

package/dist/Outputs/ProgressBar/StatusBarFactory.d.ts

@@ -0,0 +1,5 @@
+import ProgressBar, { ProgressBarFormat } from "./ProgressBar";
+import { StatusBar } from "./StatusBar";
+export declare class StatusBarFactory {
+    static create(type: ProgressBarFormat, progressbar: ProgressBar): StatusBar;
+}

package/dist/Outputs/ProgressBar/StatusBarFactory.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusBarFactory = void 0;
+const StatusBarNormal_1 = __importDefault(require("./StatusBarNormal"));
+const StatusBarVerbose_1 = __importDefault(require("./StatusBarVerbose"));
+class StatusBarFactory {
+    static create(type, progressbar) {
+        switch (type) {
+            case 'verbose':
+                return new StatusBarVerbose_1.default(progressbar);
+            case 'normal':
+            default:
+                return new StatusBarNormal_1.default(progressbar);
+        }
+    }
+}
+exports.StatusBarFactory = StatusBarFactory;

package/dist/Outputs/ProgressBar/StatusBarNormal.d.ts

@@ -0,0 +1,6 @@
+import { StatusBar, StatusBarInfo } from './StatusBar';
+import ProgressBar from './ProgressBar';
+export default class StatusBarNormal extends StatusBar {
+    constructor(progressbar: ProgressBar);
+    getInfo(perc: number): StatusBarInfo;
+}

package/dist/Outputs/ProgressBar/StatusBarNormal.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StatusBar_1 = require("./StatusBar");
+class StatusBarNormal extends StatusBar_1.StatusBar {
+    constructor(progressbar) {
+        super(progressbar);
+    }
+    getInfo(perc) {
+        const currentStr = this.progressbar.current.toString();
+        const totalStr = this.progressbar.getTotal().toString();
+        const padding = totalStr.length * 2 + 2 - (totalStr.length + currentStr.length + 1);
+        const prefix = '\r' + `${currentStr}/${totalStr}` + ' '.repeat(padding) + '[';
+        const disp = `${(perc * 100).toFixed(1)}%`;
+        const suffix = ']' + ' '.repeat(6 - disp.length) + `${disp}%`;
+        const size = this.progressbar.getSize() - prefix.length - suffix.length - 2;
+        return { prefix, suffix, size };
+    }
+}
+exports.default = StatusBarNormal;

package/dist/Outputs/ProgressBar/StatusBarVerbose.d.ts

@@ -0,0 +1,6 @@
+import { StatusBar, StatusBarInfo } from './StatusBar';
+import ProgressBar from './ProgressBar';
+export default class StatusBarVerbose extends StatusBar {
+    constructor(progressbar: ProgressBar);
+    getInfo(perc: number): StatusBarInfo;
+}

package/dist/Outputs/ProgressBar/StatusBarVerbose.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StatusBar_1 = require("./StatusBar");
+class StatusBarVerbose extends StatusBar_1.StatusBar {
+    constructor(progressbar) {
+        super(progressbar);
+    }
+    getInfo(perc) {
+        const elapsed = (new Date().getTime() / 1000) - this.progressbar.startTime;
+        const rate = this.progressbar.current > 0 ? elapsed / this.progressbar.current : 0;
+        const left = this.progressbar.getTotal() - this.progressbar.current;
+        const eta = (rate * left).toFixed(1);
+        const disp = (perc * 100).toFixed(1);
+        const prefix = '\r[';
+        const suffix = `] ${disp}% ${this.progressbar.current}/${this.progressbar.getTotal()} remaining: ${eta}s. elapsed: ${elapsed.toFixed(1)}s.`;
+        const size = this.progressbar.getSize() - suffix.length - 1;
+        return { prefix, suffix, size };
+    }
+}
+exports.default = StatusBarVerbose;

package/dist/Outputs/ProgressBar.d.ts

@@ -0,0 +1,22 @@
+export default class ProgressBar {
+    private total;
+    current: number;
+    startTime: number | null;
+    private size;
+    private progressStyle;
+    private format;
+    constructor(total: number, size?: number | null);
+    setTotal(total: number): void;
+    getTotal(): number;
+    setFormat(format: 'normal' | 'verbose' | 'minimal'): void;
+    setSize(size: number): void;
+    getSize(): number;
+    start(message?: string): void;
+    advance(): null | undefined;
+    finish(message?: string): void;
+    private getStatusBarNormal;
+    private getStatusBarVerbose;
+    private getStatusBarMinimal;
+    useShapeProgress(): void;
+    useArrowProgress(): void;
+}

package/dist/Outputs/ProgressBar.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ARROW_PROGRESS_STYLE = {
+    complete: '=',
+    incomplete: '-',
+    head: '>',
+};
+const SHAPE_PROGRESS_STYLE = {
+    complete: '#',
+    incomplete: '_',
+    head: '#',
+};
+class ProgressBar {
+    total;
+    current = 0;
+    startTime = null;
+    size;
+    progressStyle = ARROW_PROGRESS_STYLE;
+    format = 'normal';
+    constructor(total, size = null) {
+        this.total = total;
+        this.size = size === null ? process.stdout.columns : size;
+    }
+    setTotal(total) {
+        this.total = total;
+    }
+    getTotal() {
+        return this.total;
+    }
+    setFormat(format) {
+        this.format = format;
+    }
+    setSize(size) {
+        const terminalWidth = process.stdout.columns;
+        if (terminalWidth < size) {
+            this.size = terminalWidth;
+        }
+        else {
+            this.size = size;
+        }
+    }
+    getSize() {
+        return this.size;
+    }
+    start(message = '') {
+        this.current = 0;
+        this.startTime = new Date().getTime() / 1000;
+        console.log(message);
+    }
+    advance() {
+        this.current++;
+        if (this.total < this.current || this.startTime === null) {
+            return null;
+        }
+        let now = new Date().getTime() / 1000;
+        let perc = this.current / this.total;
+        let statusBar = '';
+        switch (this.format) {
+            case 'verbose':
+                statusBar = this.getStatusBarVerbose(now, perc);
+                break;
+            case 'minimal':
+                statusBar = this.getStatusBarMinimal(now, perc);
+                break;
+            case 'normal':
+            default:
+                statusBar = this.getStatusBarNormal(now, perc);
+                break;
+        }
+        process.stdout.write(statusBar);
+        if (this.current === this.total) {
+            process.stdout.write('\n');
+        }
+    }
+    finish(message = '') {
+        this.current = this.total;
+        console.log(message);
+    }
+    getStatusBarNormal(now, perc) {
+        const size = this.getSize() - 60;
+        let bar = Math.floor(perc * size);
+        const currentStr = this.current.toString();
+        const totalStr = this.total.toString();
+        const padding = (totalStr.length * 2 + 2) - (totalStr.length + currentStr.length + 1);
+        let statusBar = '\r' + `${this.current}/${this.total}` + ' '.repeat(padding) + '[';
+        statusBar += this.progressStyle.complete.repeat(bar);
+        if (bar < size) {
+            statusBar += this.progressStyle.head;
+            statusBar += this.progressStyle.incomplete.repeat(size - bar - 1);
+        }
+        let disp = (perc * 100).toFixed(1);
+        statusBar += `] ${disp}%`;
+        return statusBar;
+    }
+    getStatusBarVerbose(now, perc) {
+        const size = this.getSize() - 60;
+        let bar = Math.floor(perc * size);
+        let statusBar = '\r[';
+        statusBar += this.progressStyle.complete.repeat(bar);
+        if (bar < size) {
+            statusBar += this.progressStyle.head;
+            statusBar += this.progressStyle.incomplete.repeat(size - bar - 1);
+        }
+        let disp = (perc * 100).toFixed(1);
+        statusBar += `] ${disp}% ${this.current}/${this.total}`;
+        let elapsed = now - this.startTime;
+        let rate = this.current > 0 ? elapsed / this.current : 0;
+        let left = this.total - this.current;
+        let eta = (rate * left).toFixed(1);
+        statusBar += ` remaining: ${eta}s. elapsed: ${elapsed.toFixed(1)}s.`;
+        return statusBar;
+    }
+    getStatusBarMinimal(now, perc) {
+        return '\rProgress: ' + (perc * 100).toFixed(1) + '%';
+    }
+    useShapeProgress() {
+        this.progressStyle = SHAPE_PROGRESS_STYLE;
+    }
+    useArrowProgress() {
+        this.progressStyle = ARROW_PROGRESS_STYLE;
+    }
+}
+exports.default = ProgressBar;