@tsed/cli-core/lib/esm/CliCore.js

Build your CLI with TypeScript and Decorators

var CliCore_1;
import { __decorate } from "tslib";
import "@tsed/logger-std";
// import "@tsed/logger/layouts/ColoredLayout";
import { join, resolve } from "node:path";
import { Type } from "@tsed/core";
import { inject, InjectorService, Module } from "@tsed/di";
import chalk from "chalk";
import { Command } from "commander";
import semver from "semver";
import updateNotifier from "update-notifier";
import { CliError } from "./domains/CliError.js";
import { CliConfiguration } from "./services/CliConfiguration.js";
import { CliPackageJson } from "./services/CliPackageJson.js";
import { CliService } from "./services/CliService.js";
import { ProjectPackageJson } from "./services/ProjectPackageJson.js";
import { createInjector } from "./utils/createInjector.js";
import { loadPlugins } from "./utils/loadPlugins.js";
import { resolveConfiguration } from "./utils/resolveConfiguration.js";
function isHelpManual(argv) {
    return argv.includes("-h") || argv.includes("--help");
}
let CliCore = CliCore_1 = class CliCore {
    constructor() {
        this.injector = inject(InjectorService);
        this.cliService = inject(CliService);
    }
    static checkNodeVersion(wanted, id) {
        if (!semver.satisfies(process.version, wanted)) {
            console.log(chalk.red("You are using Node " +
                process.version +
                ", but this version of " +
                id +
                " requires Node " +
                wanted +
                ".\nPlease upgrade your Node version."));
            process.exit(1);
        }
        return this;
    }
    static async create(settings, module = CliCore_1) {
        settings = resolveConfiguration(settings);
        const injector = this.createInjector(settings);
        settings.plugins && (await loadPlugins());
        await this.loadInjector(injector, module);
        await injector.emit("$onReady");
        return injector.get(CliCore_1);
    }
    static async bootstrap(settings, module = CliCore_1) {
        const cli = await this.create(settings, module);
        return cli.bootstrap();
    }
    static async loadInjector(injector, module = CliCore_1) {
        await injector.emit("$beforeInit");
        injector.addProvider(CliCore_1, {
            useClass: module
        });
        await injector.load();
        await injector.invoke(module);
        await injector.emit("$afterInit");
        injector.settings.set("loaded", true);
    }
    static async updateNotifier(pkg) {
        updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
        return this;
    }
    static createInjector(settings) {
        const argv = settings.argv || process.argv;
        return createInjector({
            ...settings,
            name: settings.name || "tsed",
            argv,
            project: {
                rootDir: this.getProjectRoot(argv),
                srcDir: "src",
                scriptsDir: "scripts",
                ...(settings.project || {})
            }
        });
    }
    static getProjectRoot(argv) {
        if (!isHelpManual(argv)) {
            const projectRoot = new Command().option("-r, --root-dir <path>", "Project root directory").allowUnknownOption(true).parse(argv).opts().rootDir || "";
            return resolve(join(process.cwd(), projectRoot));
        }
        return process.cwd();
    }
    async bootstrap() {
        try {
            await this.cliService.parseArgs(this.injector.settings.get("argv"));
        }
        catch (er) {
            throw new CliError({ origin: er, cli: this });
        }
        return this;
    }
};
CliCore = CliCore_1 = __decorate([
    Module({
        imports: [CliPackageJson, ProjectPackageJson, CliService, CliConfiguration]
    })
], CliCore);
export { CliCore };