@tsed/cli-core 6.0.0-beta.1 → 6.0.0-beta.2

package/lib/esm/CliCore.js

@@ -1,7 +1,7 @@
 var CliCore_1;
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 import { Type } from "@tsed/core";
-import { Inject, InjectorService, Module } from "@tsed/di";
+import { inject, InjectorService, Module } from "@tsed/di";
 import chalk from "chalk";
 import { Command } from "commander";
 import { join, resolve } from "path";
@@ -19,6 +19,10 @@ 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 " +
@@ -35,7 +39,7 @@ let CliCore = CliCore_1 = class CliCore {
     static async create(settings, module = CliCore_1) {
         settings = resolveConfiguration(settings);
         const injector = this.createInjector(settings);
-        settings.plugins && (await loadPlugins(injector));
+        settings.plugins && (await loadPlugins());
         await this.loadInjector(injector, module);
         await injector.emit("$onReady");
         return injector.get(CliCore_1);
@@ -89,14 +93,6 @@ let CliCore = CliCore_1 = class CliCore {
         return this;
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", InjectorService)
-], CliCore.prototype, "injector", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliService)
-], CliCore.prototype, "cliService", void 0);
 CliCore = CliCore_1 = __decorate([
     Module({
         imports: [CliPackageJson, ProjectPackageJson, CliService, CliConfiguration]

package/lib/esm/services/CliDockerComposeYaml.js

@@ -1,12 +1,17 @@
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 import { setValue } from "@tsed/core";
-import { Inject, Injectable } from "@tsed/di";
+import { inject, Injectable } from "@tsed/di";
 import { snakeCase } from "change-case";
 import { join } from "path";
 import { CliFs } from "./CliFs.js";
 import { CliYaml } from "./CliYaml.js";
 import { ProjectPackageJson } from "./ProjectPackageJson.js";
 let CliDockerComposeYaml = class CliDockerComposeYaml {
+    constructor() {
+        this.cliYaml = inject(CliYaml);
+        this.fs = inject(CliFs);
+        this.projectPackageJson = inject(ProjectPackageJson);
+    }
     read() {
         const path = "docker-compose.yml";
         const file = !this.fs.exists(path) ? this.fs.findUpFile(this.projectPackageJson.dir, path) : path;
@@ -80,18 +85,6 @@ let CliDockerComposeYaml = class CliDockerComposeYaml {
         }
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", CliYaml)
-], CliDockerComposeYaml.prototype, "cliYaml", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliFs)
-], CliDockerComposeYaml.prototype, "fs", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], CliDockerComposeYaml.prototype, "projectPackageJson", void 0);
 CliDockerComposeYaml = __decorate([
     Injectable()
 ], CliDockerComposeYaml);

package/lib/esm/services/CliHooks.js

@@ -1,12 +1,13 @@
-import { __decorate, __metadata } from "tslib";
-import { Inject, Injectable, InjectorService } from "@tsed/di";
+import { __decorate } from "tslib";
+import { Injectable, injector } from "@tsed/di";
 let CliHooks = class CliHooks {
     async emit(hookName, cmd, ...args) {
-        const providers = this.injector.getProviders();
+        const inj = injector();
+        const providers = inj.getProviders();
         let results = [];
         for (const provider of providers) {
             if (provider.useClass) {
-                const instance = this.injector.get(provider.token);
+                const instance = inj.get(provider.token);
                 if (provider.store.has(hookName)) {
                     const props = provider.store.get(hookName)[cmd];
                     if (props) {
@@ -20,10 +21,6 @@ let CliHooks = class CliHooks {
         return results.filter((o) => o !== undefined);
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", InjectorService)
-], CliHooks.prototype, "injector", void 0);
 CliHooks = __decorate([
     Injectable()
 ], CliHooks);

package/lib/esm/services/CliHttpClient.js

@@ -1,13 +1,17 @@
 var CliHttpClient_1;
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 import { cleanObject } from "@tsed/core";
-import { Inject, Injectable } from "@tsed/di";
+import { inject, Injectable } from "@tsed/di";
 import axios, {} from "axios";
 import { stringify } from "querystring";
 import { URL } from "url";
 import { CliHttpLogClient } from "./CliHttpLogClient.js";
 import { CliProxyAgent } from "./CliProxyAgent.js";
 let CliHttpClient = CliHttpClient_1 = class CliHttpClient extends CliHttpLogClient {
+    constructor() {
+        super(...arguments);
+        this.cliProxyAgent = inject(CliProxyAgent);
+    }
     static getParamsSerializer(params) {
         return stringify(cleanObject(params));
     }
@@ -93,10 +97,6 @@ let CliHttpClient = CliHttpClient_1 = class CliHttpClient extends CliHttpLogClie
         return withHeaders ? { data, headers: result?.headers } : data;
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", CliProxyAgent)
-], CliHttpClient.prototype, "cliProxyAgent", void 0);
 CliHttpClient = CliHttpClient_1 = __decorate([
     Injectable()
 ], CliHttpClient);

package/lib/esm/services/CliHttpLogClient.js

@@ -1,12 +1,13 @@
 import { __decorate, __metadata, __param } from "tslib";
 import { getValue } from "@tsed/core";
-import { Inject, Opts } from "@tsed/di";
+import { inject, Opts } from "@tsed/di";
 import { Logger } from "@tsed/logger";
 import querystring from "querystring";
 import { logToCurl } from "../utils/logToCurl.js";
 let CliHttpLogClient = class CliHttpLogClient {
     // @ts-ignore
     constructor(options = {}) {
+        this.logger = inject(Logger);
         this.callee = options.callee || "http";
     }
     onSuccess(options) {
@@ -68,10 +69,6 @@ let CliHttpLogClient = class CliHttpLogClient {
         };
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", Logger)
-], CliHttpLogClient.prototype, "logger", void 0);
 CliHttpLogClient = __decorate([
     __param(0, Opts),
     __metadata("design:paramtypes", [Object])

package/lib/esm/services/CliLoadFile.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { Inject, Injectable } from "@tsed/di";
+import { inject, Injectable } from "@tsed/di";
 import { default as Ajv } from "ajv";
 import { extname } from "path";
 import { CliFs } from "./CliFs.js";
@@ -8,6 +8,8 @@ let CliLoadFile = class CliLoadFile {
     // @ts-ignore
     #ajv;
     constructor() {
+        this.cliYaml = inject(CliYaml);
+        this.cliFs = inject(CliFs);
         const options = {
             verbose: false,
             coerceTypes: true,
@@ -48,14 +50,6 @@ let CliLoadFile = class CliLoadFile {
         return config;
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", CliYaml)
-], CliLoadFile.prototype, "cliYaml", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliFs)
-], CliLoadFile.prototype, "cliFs", void 0);
 CliLoadFile = __decorate([
     Injectable(),
     __metadata("design:paramtypes", [])

package/lib/esm/services/CliPackageJson.js

@@ -1,8 +1,11 @@
-import { Configuration, Inject, registerProvider } from "@tsed/di";
+import { Configuration, Inject, inject, registerProvider } from "@tsed/di";
 import {} from "../interfaces/PackageJson.js";
 export function CliPackageJson() {
     return Inject(CliPackageJson);
 }
+export function cliPackageJson() {
+    return inject(CliPackageJson);
+}
 registerProvider({
     provide: CliPackageJson,
     deps: [Configuration],

package/lib/esm/services/CliPlugins.js

@@ -1,5 +1,5 @@
-import { __decorate, __metadata } from "tslib";
-import { Constant, Inject, Injectable, InjectorService } from "@tsed/di";
+import { __decorate } from "tslib";
+import { constant, inject, Injectable } from "@tsed/di";
 import chalk from "chalk";
 import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
 import { PackageManagersModule } from "../packageManagers/PackageManagersModule.js";
@@ -16,13 +16,18 @@ function mapPlugins({ package: { name, description = "", ...otherProps } }) {
     };
 }
 let CliPlugins = class CliPlugins {
+    constructor() {
+        this.name = constant("name", "");
+        this.loadPlugins = loadPlugins;
+        this.npmRegistryClient = inject(NpmRegistryClient);
+        this.cliHooks = inject(CliHooks);
+        this.packageJson = inject(ProjectPackageJson);
+        this.packageManagers = inject(PackageManagersModule);
+    }
     async searchPlugins(keyword = "", options = {}) {
         const result = await this.npmRegistryClient.search(this.getKeyword(keyword), options);
         return result.filter(({ package: { name } }) => this.isPlugin(name)).map(mapPlugins);
     }
-    loadPlugins() {
-        return loadPlugins(this.injector);
-    }
     addPluginsDependencies(ctx) {
         const plugins = Object.keys(this.packageJson.devDependencies).filter((name) => this.isPlugin(name));
         const tasks = plugins.map((plugin) => {
@@ -53,30 +58,6 @@ let CliPlugins = class CliPlugins {
         return name.startsWith(`@${this.name}/cli-plugin`) || name.includes(`${this.name}-cli-plugin`);
     }
 };
-__decorate([
-    Constant("name"),
-    __metadata("design:type", String)
-], CliPlugins.prototype, "name", void 0);
-__decorate([
-    Inject(NpmRegistryClient),
-    __metadata("design:type", NpmRegistryClient)
-], CliPlugins.prototype, "npmRegistryClient", void 0);
-__decorate([
-    Inject(InjectorService),
-    __metadata("design:type", InjectorService)
-], CliPlugins.prototype, "injector", void 0);
-__decorate([
-    Inject(CliHooks),
-    __metadata("design:type", CliHooks)
-], CliPlugins.prototype, "cliHooks", void 0);
-__decorate([
-    Inject(ProjectPackageJson),
-    __metadata("design:type", ProjectPackageJson)
-], CliPlugins.prototype, "packageJson", void 0);
-__decorate([
-    Inject(PackageManagersModule),
-    __metadata("design:type", PackageManagersModule)
-], CliPlugins.prototype, "packageManagers", void 0);
 CliPlugins = __decorate([
     Injectable()
 ], CliPlugins);

package/lib/esm/services/CliProxyAgent.js

@@ -1,5 +1,5 @@
-import { __decorate, __metadata } from "tslib";
-import { Configuration, Inject, Injectable, Value } from "@tsed/di";
+import { __decorate } from "tslib";
+import { Configuration, Inject, inject, Injectable, refValue } from "@tsed/di";
 import { camelCase } from "change-case";
 import tunnel from "tunnel";
 import { URL } from "url";
@@ -7,13 +7,18 @@ import { coerce } from "../utils/coerce.js";
 import { CliExeca } from "./CliExeca.js";
 import { ProjectPackageJson } from "./ProjectPackageJson.js";
 let CliProxyAgent = class CliProxyAgent {
+    constructor() {
+        this.proxySettings = refValue("proxy", {});
+        this.projectPackageJson = Inject(ProjectPackageJson);
+        this.cliExeca = inject(CliExeca);
+    }
     hasProxy() {
-        return !!this.proxySettings.url;
+        return !!this.proxySettings.value.url;
     }
     get(type) {
         if (this.hasProxy()) {
-            const { strictSsl = true } = this.proxySettings;
-            const url = new URL(this.proxySettings.url);
+            const { strictSsl = true } = this.proxySettings.value;
+            const url = new URL(this.proxySettings.value.url);
             const protocol = url.protocol.replace(":", "");
             const options = {
                 proxy: {
@@ -60,25 +65,13 @@ let CliProxyAgent = class CliProxyAgent {
         const [proxy, httpProxy, httpsProxy, strictSsl] = result.map(coerce);
         const url = httpsProxy || httpProxy || proxy;
         if (url) {
-            this.proxySettings = {
+            this.proxySettings.value = {
                 url,
                 strictSsl: coerce(strictSsl) !== false
             };
         }
     }
 };
-__decorate([
-    Value("proxy", {}),
-    __metadata("design:type", Object)
-], CliProxyAgent.prototype, "proxySettings", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], CliProxyAgent.prototype, "projectPackageJson", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliExeca)
-], CliProxyAgent.prototype, "cliExeca", void 0);
 CliProxyAgent = __decorate([
     Injectable(),
     Configuration({

package/lib/esm/services/CliRunScript.js

@@ -1,7 +1,7 @@
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 // @ts-ignore
 import runScript from "@npmcli/run-script";
-import { Inject, Injectable } from "@tsed/di";
+import { inject, Injectable } from "@tsed/di";
 import { ProjectPackageJson } from "./ProjectPackageJson.js";
 let CliRunScript = class CliRunScript {
     run(cmd, args, options = {}) {
@@ -9,17 +9,13 @@ let CliRunScript = class CliRunScript {
             event: "run",
             ...options,
             cmd: `${cmd} ${args.join(" ")}`,
-            path: options.cwd || this.projectPackageJson.dir,
+            path: options.cwd || inject(ProjectPackageJson).dir,
             env: options.env || {},
             stdio: options.stdio || "inherit",
             banner: false
         });
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], CliRunScript.prototype, "projectPackageJson", void 0);
 CliRunScript = __decorate([
     Injectable()
 ], CliRunScript);

package/lib/esm/services/CliService.js

@@ -1,6 +1,6 @@
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 import { classOf } from "@tsed/core";
-import { Constant, DIContext, getContext, Inject, Injectable, InjectorService, Provider, runInContext } from "@tsed/di";
+import { $emit, configuration, constant, destroyInjector, DIContext, getContext, inject, Injectable, injector, logger, Provider, runInContext } from "@tsed/di";
 import { Argument, Command } from "commander";
 import Inquirer from "inquirer";
 // @ts-ignore
@@ -18,8 +18,12 @@ import { ProjectPackageJson } from "./ProjectPackageJson.js";
 Inquirer.registerPrompt("autocomplete", inquirer_autocomplete_prompt);
 let CliService = class CliService {
     constructor() {
+        this.reinstallAfterRun = constant("project.reinstallAfterRun", false);
         this.program = new Command();
-        this.reinstallAfterRun = false;
+        this.pkg = constant("pkg", { version: "1.0.0" });
+        this.hooks = inject(CliHooks);
+        this.projectPkg = inject(ProjectPackageJson);
+        this.packageManagers = inject(PackageManagersModule);
         this.commands = new Map();
     }
     /**
@@ -40,7 +44,7 @@ let CliService = class CliService {
      */
     runLifecycle(cmdName, data = {}, $ctx) {
         return runInContext($ctx, async () => {
-            await this.injector.emit("$loadPackageJson");
+            await $emit("$loadPackageJson");
             data = await this.beforePrompt(cmdName, data);
             $ctx.set("data", data);
             data = await this.prompt(cmdName, data);
@@ -54,12 +58,12 @@ let CliService = class CliService {
             await this.exec(cmdName, data, $ctx);
         }
         catch (er) {
-            await this.injector.emit("$onFinish", er);
-            await this.injector.destroy();
+            await $emit("$onFinish", er);
+            await destroyInjector();
             throw er;
         }
-        await this.injector.emit("$onFinish");
-        await this.injector.destroy();
+        await $emit("$onFinish");
+        await destroyInjector();
     }
     async exec(cmdName, data, $ctx) {
         const initialTasks = await this.getTasks(cmdName, data);
@@ -83,7 +87,7 @@ let CliService = class CliService {
      */
     async beforePrompt(cmdName, ctx = {}) {
         const provider = this.commands.get(cmdName);
-        const instance = this.injector.get(provider.useClass);
+        const instance = inject(provider.useClass);
         const verbose = ctx.verbose;
         if (instance.$beforePrompt) {
             ctx = await instance.$beforePrompt(JSON.parse(JSON.stringify(ctx)));
@@ -98,7 +102,7 @@ let CliService = class CliService {
      */
     async prompt(cmdName, ctx = {}) {
         const provider = this.commands.get(cmdName);
-        const instance = this.injector.get(provider.useClass);
+        const instance = inject(provider.useClass);
         if (instance.$prompt) {
             const questions = [
                 ...(await instance.$prompt(ctx)),
@@ -121,7 +125,7 @@ let CliService = class CliService {
     async getTasks(cmdName, data) {
         const $ctx = getContext();
         const provider = this.commands.get(cmdName);
-        const instance = this.injector.get(provider.token);
+        const instance = inject(provider.token);
         data = this.mapData(cmdName, data, $ctx);
         if (instance.$beforeExec) {
             await instance.$beforeExec(data);
@@ -130,7 +134,7 @@ let CliService = class CliService {
     }
     async getPostInstallTasks(cmdName, data) {
         const provider = this.commands.get(cmdName);
-        const instance = this.injector.get(provider.useClass);
+        const instance = inject(provider.useClass);
         data = this.mapData(cmdName, data, getContext());
         return [
             ...(instance.$postInstall ? await instance.$postInstall(data) : []),
@@ -157,15 +161,15 @@ let CliService = class CliService {
             };
             const $ctx = new DIContext({
                 id: v4(),
-                injector: this.injector,
-                logger: this.injector.logger,
-                level: this.injector.logger.level,
+                injector: injector(),
+                logger: logger(),
+                level: logger().level,
                 maxStackSize: 0,
                 platform: "CLI"
             });
             $ctx.set("data", data);
             $ctx.set("command", metadata);
-            this.injector.settings.set("command.metadata", metadata);
+            configuration().set("command.metadata", metadata);
             return this.runLifecycle(name, data, $ctx);
         };
         if (alias) {
@@ -180,21 +184,23 @@ let CliService = class CliService {
         return cmd;
     }
     load() {
-        this.injector.getProviders("command").forEach((provider) => this.build(provider));
+        injector()
+            .getProviders("command")
+            .forEach((provider) => this.build(provider));
     }
     mapData(cmdName, data, $ctx) {
         const provider = this.commands.get(cmdName);
-        const instance = this.injector.get(provider.useClass);
+        const instance = inject(provider.useClass);
         const verbose = data.verbose;
         if (instance.$mapContext) {
             data = instance.$mapContext(JSON.parse(JSON.stringify(data)));
             data.verbose = verbose;
         }
         if (data.verbose) {
-            this.injector.logger.level = "debug";
+            logger().level = "debug";
         }
         else {
-            this.injector.logger.level = "info";
+            logger().level = "info";
         }
         data.bindLogger = $ctx.get("command").bindLogger;
         $ctx.set("data", data);
@@ -249,30 +255,6 @@ let CliService = class CliService {
         }, cmd);
     }
 };
-__decorate([
-    Constant("project.reinstallAfterRun", false),
-    __metadata("design:type", Object)
-], CliService.prototype, "reinstallAfterRun", void 0);
-__decorate([
-    Constant("pkg", { version: "1.0.0" }),
-    __metadata("design:type", Object)
-], CliService.prototype, "pkg", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", InjectorService)
-], CliService.prototype, "injector", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliHooks)
-], CliService.prototype, "hooks", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", ProjectPackageJson)
-], CliService.prototype, "projectPkg", void 0);
-__decorate([
-    Inject(PackageManagersModule),
-    __metadata("design:type", PackageManagersModule)
-], CliService.prototype, "packageManagers", void 0);
 CliService = __decorate([
     Injectable()
 ], CliService);

package/lib/esm/services/CliYaml.js

@@ -1,8 +1,11 @@
-import { __decorate, __metadata } from "tslib";
-import { Inject, Injectable } from "@tsed/di";
+import { __decorate } from "tslib";
+import { inject, Injectable } from "@tsed/di";
 import JsYaml from "js-yaml";
 import { CliFs } from "./CliFs.js";
 let CliYaml = class CliYaml {
+    constructor() {
+        this.fs = inject(CliFs);
+    }
     async read(path) {
         const content = await this.fs.readFile(path, { encoding: "utf8" });
         return JsYaml.load(content);
@@ -12,10 +15,6 @@ let CliYaml = class CliYaml {
         return this.fs.writeFile(path, content, { encoding: "utf8" });
     }
 };
-__decorate([
-    Inject(),
-    __metadata("design:type", CliFs)
-], CliYaml.prototype, "fs", void 0);
 CliYaml = __decorate([
     Injectable()
 ], CliYaml);

package/lib/esm/services/NpmRegistryClient.js

@@ -1,6 +1,6 @@
 var NpmRegistryClient_1;
-import { __decorate, __metadata } from "tslib";
-import { Inject, Injectable } from "@tsed/di";
+import { __decorate } from "tslib";
+import { inject, Injectable } from "@tsed/di";
 import registry_url from "registry-url";
 import url from "url";
 import { CliHttpClient } from "./CliHttpClient.js";
@@ -15,6 +15,9 @@ export function addSuffix(pattern, suffix) {
 }
 export const SCOPE_SEPARATOR = "%2f";
 let NpmRegistryClient = NpmRegistryClient_1 = class NpmRegistryClient {
+    constructor() {
+        this.httpClient = inject(CliHttpClient);
+    }
     static escapeName(name) {
         // scoped packages contain slashes and the npm registry expects them to be escaped
         return name.replace("/", SCOPE_SEPARATOR);
@@ -106,10 +109,6 @@ let NpmRegistryClient = NpmRegistryClient_1 = class NpmRegistryClient {
         };
     }
 };
-__decorate([
-    Inject(CliHttpClient),
-    __metadata("design:type", CliHttpClient)
-], NpmRegistryClient.prototype, "httpClient", void 0);
 NpmRegistryClient = NpmRegistryClient_1 = __decorate([
     Injectable()
 ], NpmRegistryClient);

package/lib/esm/services/ProjectPackageJson.js

@@ -1,6 +1,6 @@
-import { __decorate, __metadata, __param } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { getValue, setValue } from "@tsed/core";
-import { Configuration, Injectable } from "@tsed/di";
+import { configuration, constant, inject, Injectable } from "@tsed/di";
 import { dirname, join } from "path";
 import { readPackageUpSync } from "read-pkg-up";
 import { isValidVersion } from "../utils/isValidVersion.js";
@@ -29,11 +29,10 @@ function mapPackages(deps) {
     }, { valid: {}, invalid: {} });
 }
 let ProjectPackageJson = class ProjectPackageJson {
-    constructor(configuration, fs) {
-        this.configuration = configuration;
-        this.fs = fs;
+    constructor() {
         this.rewrite = false;
         this.reinstall = false;
+        this.fs = inject(CliFs);
         this.setRaw({
             name: "",
             version: "1.0.0",
@@ -48,10 +47,10 @@ let ProjectPackageJson = class ProjectPackageJson {
         return join(this.dir, "package.json");
     }
     get dir() {
-        return String(this.configuration.project?.rootDir);
+        return String(constant("project.rootDir"));
     }
     set dir(dir) {
-        this.configuration.project.rootDir = dir;
+        configuration().project.rootDir = dir;
         this.read();
     }
     get name() {
@@ -83,7 +82,7 @@ let ProjectPackageJson = class ProjectPackageJson {
         };
     }
     get preferences() {
-        return this.raw[this.configuration.name];
+        return this.raw[constant("name")];
     }
     $loadPackageJson() {
         return this.read();
@@ -97,11 +96,12 @@ let ProjectPackageJson = class ProjectPackageJson {
         return this;
     }
     setRaw(pkg) {
-        const projectPreferences = this.configuration.defaultProjectPreferences;
-        const preferences = getValue(pkg, this.configuration.name);
+        const config = configuration();
+        const projectPreferences = config.defaultProjectPreferences;
+        const preferences = getValue(pkg, config.name);
         this.raw = {
             ...pkg,
-            [this.configuration.name]: {
+            [config.name]: {
                 ...(projectPreferences && projectPreferences(pkg)),
                 ...preferences
             }
@@ -150,7 +150,7 @@ let ProjectPackageJson = class ProjectPackageJson {
         return this;
     }
     setPreference(key, value) {
-        setValue(this.raw, `${this.configuration.name}.${key}`, value);
+        setValue(this.raw, `${constant("name")}.${key}`, value);
         this.rewrite = true;
         return;
     }
@@ -212,7 +212,7 @@ let ProjectPackageJson = class ProjectPackageJson {
     refresh() {
         this.reinstall = false;
         this.rewrite = false;
-        const cwd = this.configuration.get("project.rootDir");
+        const cwd = constant("project.rootDir");
         const pkgPath = join(String(cwd), "package.json");
         const pkg = this.fs.readJsonSync(pkgPath, { encoding: "utf8" });
         pkg.scripts = {
@@ -227,17 +227,18 @@ let ProjectPackageJson = class ProjectPackageJson {
             ...this.raw.devDependencies,
             ...pkg.devDependencies
         };
-        pkg[this.configuration.name] = {
-            ...this.raw[this.configuration.name],
-            ...pkg[this.configuration.name]
+        const name = constant("name");
+        pkg[name] = {
+            ...this.raw[name],
+            ...pkg[name]
         };
         this.raw = pkg;
         return this;
     }
     getPackageJson() {
-        const cwd = this.configuration.get("project.rootDir");
-        const disableReadUpPkg = this.configuration.get("command.metadata.disableReadUpPkg");
-        const name = this.configuration.get("name");
+        const cwd = constant("project.rootDir");
+        const disableReadUpPkg = constant("command.metadata.disableReadUpPkg");
+        const name = constant("name");
         const pkgPath = join(String(cwd), "package.json");
         const fileExists = this.fs.exists(pkgPath);
         if (!disableReadUpPkg && !fileExists) {
@@ -246,14 +247,14 @@ let ProjectPackageJson = class ProjectPackageJson {
             });
             if (result && result.path) {
                 const pkgPath = dirname(result.path);
-                this.configuration.set("project.root", pkgPath);
+                configuration().set("project.root", pkgPath);
                 const pkg = this.fs.readJsonSync(result.path, { encoding: "utf8" });
                 return { ...this.getEmptyPackageJson(name), ...pkg };
             }
         }
         if (disableReadUpPkg && fileExists) {
             const pkg = this.fs.readJsonSync(pkgPath, { encoding: "utf8" });
-            this.configuration.set("project.root", pkgPath);
+            configuration().set("project.root", pkgPath);
             return { ...this.getEmptyPackageJson(name), ...pkg };
         }
         return this.getEmptyPackageJson(name);
@@ -271,7 +272,6 @@ let ProjectPackageJson = class ProjectPackageJson {
 };
 ProjectPackageJson = __decorate([
     Injectable({}),
-    __param(0, Configuration()),
-    __metadata("design:paramtypes", [Object, CliFs])
+    __metadata("design:paramtypes", [])
 ], ProjectPackageJson);
 export { ProjectPackageJson };

package/lib/esm/services/Renderer.js

@@ -1,7 +1,7 @@
-import { __decorate, __metadata } from "tslib";
+import { __decorate } from "tslib";
 import "../utils/hbs/index.js";
 import { isString } from "@tsed/core";
-import { Configuration, Constant, Inject, Injectable } from "@tsed/di";
+import { Configuration, constant, inject, Injectable } from "@tsed/di";
 import { normalizePath } from "@tsed/normalize-path";
 import Consolidate from "consolidate";
 import fs from "fs-extra";
@@ -14,7 +14,10 @@ import { insertImport } from "../utils/renderer/insertImport.js";
 import { CliFs } from "./CliFs.js";
 export class Renderer {
     constructor() {
+        this.templateDir = constant("templateDir", "");
+        this.fs = inject(CliFs);
         this.cache = new Set();
+        this.configuration = inject(Configuration);
     }
     async loadPartials(cwd) {
         if (this.cache.has(cwd)) {
@@ -131,18 +134,6 @@ export class Renderer {
         return { output, templateDir, rootDir };
     }
 }
-__decorate([
-    Constant("templateDir"),
-    __metadata("design:type", String)
-], Renderer.prototype, "templateDir", void 0);
-__decorate([
-    Inject(),
-    __metadata("design:type", CliFs)
-], Renderer.prototype, "fs", void 0);
-__decorate([
-    Configuration(),
-    __metadata("design:type", Object)
-], Renderer.prototype, "configuration", void 0);
 let RootRendererService = class RootRendererService extends Renderer {
     get rootDir() {
         return this.configuration.project?.rootDir;

package/lib/esm/utils/createInjector.js

@@ -1,4 +1,4 @@
-import { InjectorService } from "@tsed/di";
+import { injector, InjectorService } from "@tsed/di";
 import { Logger } from "@tsed/logger";
 import { CliConfiguration } from "../services/CliConfiguration.js";
 import { ProjectPackageJson } from "../services/ProjectPackageJson.js";
@@ -11,19 +11,19 @@ function createConfiguration(injector) {
     return injector.invoke(CliConfiguration);
 }
 export function createInjector(settings = {}) {
-    const injector = new InjectorService();
-    injector.settings = createConfiguration(injector);
-    logger = injector.logger = new Logger(settings.name || "CLI");
-    injector.addProvider(ProjectPackageJson);
-    injector.settings.set(settings);
+    const inj = injector();
+    inj.settings = createConfiguration(inj);
+    logger = inj.logger = new Logger(settings.name || "CLI");
+    inj.addProvider(ProjectPackageJson);
+    inj.settings.set(settings);
     /* istanbul ignore next */
-    if (injector.settings.env === "test") {
-        injector.logger.stop();
+    if (inj.settings.env === "test") {
+        inj.logger.stop();
     }
     else {
         /* istanbul ignore next */
-        injector.logger.level = injector.settings.logger?.level || "warn";
-        injector.logger.appenders
+        inj.logger.level = inj.settings.logger?.level || "warn";
+        inj.logger.appenders
             .set("stdout", {
             type: "stdout",
             layout: {
@@ -41,5 +41,5 @@ export function createInjector(settings = {}) {
             levels: ["trace", "fatal", "error", "warn"]
         });
     }
-    return injector;
+    return inj;
 }

package/lib/esm/utils/getCommandMetadata.js

@@ -1,4 +1,4 @@
-import { Store, Type } from "@tsed/core";
+import { Store } from "@tsed/core";
 import { CommandStoreKeys } from "../domains/CommandStoreKeys.js";
 export function getCommandMetadata(token) {
     const { name, alias, args = {}, allowUnknownOption, description, options = {}, enableFeatures, disableReadUpPkg, bindLogger = true, ...opts } = Store.from(token)?.get(CommandStoreKeys.COMMAND);

package/lib/esm/utils/loadPlugins.js

@@ -1,38 +1,39 @@
-import { GlobalProviders, InjectorService } from "@tsed/di";
+import { GlobalProviders, injector, logger } from "@tsed/di";
 import chalk from "chalk";
 import figures from "figures";
 import { CliFs } from "../services/CliFs.js";
 import { ProjectPackageJson } from "../services/ProjectPackageJson.js";
 const all = (promises) => Promise.all(promises);
-export async function loadPlugins(injector) {
-    const name = injector.settings.get("name");
-    const rootDir = injector.settings.get("project.rootDir");
-    const projectPackageJson = injector.invoke(ProjectPackageJson);
-    const fs = injector.invoke(CliFs);
+export async function loadPlugins() {
+    const $inj = injector();
+    const name = $inj.settings.get("name");
+    const rootDir = $inj.settings.get("project.rootDir");
+    const projectPackageJson = $inj.invoke(ProjectPackageJson);
+    const fs = $inj.invoke(CliFs);
     const promises = Object.keys(projectPackageJson.allDependencies)
         .filter((mod) => mod.startsWith(`@${name}/cli-plugin`) || mod.includes(`${name}-cli-plugin`))
         .map(async (mod) => {
         try {
             const { default: plugin } = await fs.importModule(mod, rootDir);
-            if (!injector.has(plugin)) {
+            if (!$inj.has(plugin)) {
                 const provider = GlobalProviders.get(plugin)?.clone();
                 if (provider?.imports.length) {
                     await all(provider.imports.map(async (token) => {
-                        injector.add(token, GlobalProviders.get(token)?.clone());
-                        if (injector.settings.get("loaded")) {
-                            await injector.invoke(token);
+                        $inj.add(token, GlobalProviders.get(token)?.clone());
+                        if ($inj.settings.get("loaded")) {
+                            await $inj.invoke(token);
                         }
                     }));
                 }
-                injector.add(plugin, provider);
-                if (injector.settings.get("loaded")) {
-                    await injector.invoke(plugin);
+                $inj.add(plugin, provider);
+                if ($inj.settings.get("loaded")) {
+                    await $inj.invoke(plugin);
                 }
             }
-            injector.logger.info(chalk.green(figures.tick), mod, "module loaded");
+            logger().info(chalk.green(figures.tick), mod, "module loaded");
         }
         catch (er) {
-            injector.logger.warn(chalk.red(figures.cross), "Fail to load plugin", mod);
+            logger().warn(chalk.red(figures.cross), "Fail to load plugin", mod);
         }
     });
     await all(promises);

package/lib/types/services/CliHooks.d.ts

@@ -1,5 +1,3 @@
-import { InjectorService } from "@tsed/di";
 export declare class CliHooks {
-    injector: InjectorService;
     emit(hookName: string, cmd: string, ...args: any[]): Promise<any>;
 }

package/lib/types/services/CliPackageJson.d.ts

@@ -1,3 +1,4 @@
 import { type PackageJson } from "../interfaces/PackageJson.js";
 export type CliPackageJson = PackageJson;
-export declare function CliPackageJson(): Function;
+export declare function CliPackageJson(): any;
+export declare function cliPackageJson(): PackageJson;

package/lib/types/services/CliPlugins.d.ts

@@ -1,13 +1,13 @@
 import type { Task } from "../interfaces/index.js";
+import { loadPlugins } from "../utils/loadPlugins.js";
 export declare class CliPlugins {
     name: string;
+    readonly loadPlugins: typeof loadPlugins;
     private npmRegistryClient;
-    private injector;
     private cliHooks;
     private packageJson;
     private packageManagers;
     searchPlugins(keyword?: string, options?: any): Promise<any>;
-    loadPlugins(): Promise<void>;
     addPluginsDependencies(ctx: any): Task[];
     protected getKeyword(keyword: string): string;
     protected cleanKeyword(keyword: string): string;

package/lib/types/services/CliProxyAgent.d.ts

@@ -1,12 +1,13 @@
 import { CliExeca } from "./CliExeca.js";
-import { ProjectPackageJson } from "./ProjectPackageJson.js";
 export interface CliProxySettings {
     url: string;
     strictSsl: boolean;
 }
 export declare class CliProxyAgent {
-    proxySettings: CliProxySettings;
-    protected projectPackageJson: ProjectPackageJson;
+    readonly proxySettings: {
+        value: CliProxySettings;
+    };
+    protected projectPackageJson: any;
     protected cliExeca: CliExeca;
     hasProxy(): boolean;
     get(type: "http" | "https"): any;

package/lib/types/services/CliRunScript.d.ts

@@ -1,5 +1,3 @@
-import { ProjectPackageJson } from "./ProjectPackageJson.js";
 export declare class CliRunScript {
-    projectPackageJson: ProjectPackageJson;
     run(cmd: string, args: string[], options?: any): any;
 }

package/lib/types/services/CliService.d.ts

@@ -1,14 +1,13 @@
-import { DIContext, InjectorService } from "@tsed/di";
+import { DIContext } from "@tsed/di";
 import { Command } from "commander";
 import type { CommandMetadata } from "../interfaces/CommandMetadata.js";
 import { PackageManagersModule } from "../packageManagers/index.js";
 import { CliHooks } from "./CliHooks.js";
 import { ProjectPackageJson } from "./ProjectPackageJson.js";
 export declare class CliService {
+    readonly reinstallAfterRun: boolean;
     readonly program: Command;
-    reinstallAfterRun: boolean;
-    protected pkg: any;
-    protected injector: InjectorService;
+    protected pkg: Record<string, any>;
     protected hooks: CliHooks;
     protected projectPkg: ProjectPackageJson;
     protected packageManagers: PackageManagersModule;
@@ -24,7 +23,7 @@ export declare class CliService {
      * @param data
      * @param $ctx
      */
-    runLifecycle(cmdName: string, data: any, $ctx: DIContext): Promise<any>;
+    runLifecycle(cmdName: string, data: any, $ctx: DIContext): Promise<Promise<void>>;
     dispatch(cmdName: string, data: any, $ctx: DIContext): Promise<void>;
     exec(cmdName: string, data: any, $ctx: DIContext): Promise<any>;
     /**

package/lib/types/services/ProjectPackageJson.d.ts

@@ -1,15 +1,13 @@
-import { Configuration } from "@tsed/di";
 import type { PackageJson } from "../interfaces/PackageJson.js";
 import type { ProjectPreferences } from "../interfaces/ProjectPreferences.js";
 import { CliFs } from "./CliFs.js";
 export declare class ProjectPackageJson {
-    private configuration;
-    protected fs: CliFs;
     rewrite: boolean;
     reinstall: boolean;
     GH_TOKEN: string;
+    protected fs: CliFs;
     private raw;
-    constructor(configuration: Configuration, fs: CliFs);
+    constructor();
     get path(): string;
     get dir(): string;
     set dir(dir: string);

package/lib/types/services/Renderer.d.ts

@@ -1,5 +1,4 @@
 import "../utils/hbs/index.js";
-import { Configuration } from "@tsed/di";
 import { Observable } from "rxjs";
 import { CliFs } from "./CliFs.js";
 export interface RenderOptions {
@@ -13,9 +12,9 @@ export interface RenderOptions {
 }
 export declare abstract class Renderer {
     templateDir: string;
-    fs: CliFs;
-    cache: Set<string>;
-    protected configuration: Configuration;
+    readonly fs: CliFs;
+    readonly cache: Set<string>;
+    protected configuration: any;
     abstract get rootDir(): string;
     loadPartials(cwd: string): Promise<void>;
     render(path: string, data: any, options?: Partial<RenderOptions>): Promise<void>;

package/lib/types/utils/getCommandMetadata.d.ts

@@ -1,3 +1,3 @@
-import { Type } from "@tsed/core";
+import type { TokenProvider } from "@tsed/di";
 import type { CommandMetadata } from "../interfaces/CommandMetadata.js";
-export declare function getCommandMetadata(token: Type<any>): CommandMetadata;
+export declare function getCommandMetadata(token: TokenProvider): CommandMetadata;

package/lib/types/utils/loadPlugins.d.ts

@@ -1,2 +1 @@
-import { InjectorService } from "@tsed/di";
-export declare function loadPlugins(injector: InjectorService): Promise<void>;
+export declare function loadPlugins(): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tsed/cli-core",
   "description": "Build your CLI with TypeScript and Decorators",
-  "version": "6.0.0-beta.1",
+  "version": "6.0.0-beta.2",
   "type": "module",
   "main": "./lib/esm/index.js",
   "source": "./src/index.ts",
@@ -66,7 +66,7 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
-    "@tsed/typescript": "6.0.0-beta.1",
+    "@tsed/typescript": "6.0.0-beta.2",
     "@types/commander": "2.12.2",
     "@types/consolidate": "0.14.4",
     "@types/figures": "3.0.1",
@@ -83,8 +83,8 @@
     "vitest": "2.1.1"
   },
   "peerDependencies": {
-    "@tsed/core": ">=7.14.2",
-    "@tsed/di": ">=7.14.2"
+    "@tsed/core": ">=8.0.0-beta.2",
+    "@tsed/di": ">=8.0.0-beta.2"
   },
   "repository": "https://github.com/tsedio/tsed-cli",
   "bugs": {