@nestjs/cli 10.0.0-next.2 → 10.0.0

package/commands/new.command.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewCommand = void 0;
 const schematics_1 = require("../lib/schematics");
@@ -26,7 +17,7 @@ class NewCommand extends abstract_command_1.AbstractCommand {
             .option('-l, --language [language]', 'Programming language to be used (TypeScript or JavaScript)', 'TypeScript')
             .option('-c, --collection [collectionName]', 'Schematics collection to use', schematics_1.Collection.NESTJS)
             .option('--strict', 'Enables strict mode in TypeScript.', false)
-            .action((name, command) => __awaiter(this, void 0, void 0, function* () {
+            .action(async (name, command) => {
             const options = [];
             const availableLanguages = ['js', 'ts', 'javascript', 'typescript'];
             options.push({ name: 'directory', value: command.directory });
@@ -63,8 +54,8 @@ class NewCommand extends abstract_command_1.AbstractCommand {
             });
             const inputs = [];
             inputs.push({ name: 'name', value: name });
-            yield this.action.handle(inputs, options);
-        }));
+            await this.action.handle(inputs, options);
+        });
     }
 }
 exports.NewCommand = NewCommand;

package/commands/start.command.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartCommand = void 0;
 const ui_1 = require("../lib/ui");
@@ -25,15 +16,14 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('-d, --debug [hostport] ', 'Run in debug mode (with --inspect flag).')
             .option('--webpack', 'Use webpack for compilation (deprecated option, use --build instead).')
             .option('--webpackPath [path]', 'Path to webpack configuration.')
-            .option('--type-check', 'Enable type checking (when SWC is used).', false)
+            .option('--type-check', 'Enable type checking (when SWC is used).')
             .option('--tsc', 'Use tsc for compilation.')
             .option('--sourceRoot [sourceRoot]', 'Points at the root of the source code for the single project in standard mode structures, or the default project in monorepo mode structures.')
             .option('--entryFile [entryFile]', "Path to the entry file where this command will work with. Defaults to the one defined at your Nest's CLI config file.")
             .option('-e, --exec [binary]', 'Binary to run (default: "node").')
             .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when tsc watch mode.')
             .description('Run Nest application.')
-            .action((app, command) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            .action(async (app, command) => {
             const options = [];
             options.push({
                 name: 'config',
@@ -78,7 +68,7 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             }
             options.push({
                 name: 'builder',
-                value: (_a = command.builder) !== null && _a !== void 0 ? _a : (isWebpackEnabled ? 'webpack' : 'tsc'),
+                value: command.builder,
             });
             if (command.typeCheck && command.builder !== 'swc') {
                 console.warn(ui_1.INFO_PREFIX +
@@ -92,12 +82,12 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             inputs.push({ name: 'app', value: app });
             const flags = (0, remaining_flags_1.getRemainingFlags)(program);
             try {
-                yield this.action.handle(inputs, options, flags);
+                await this.action.handle(inputs, options, flags);
             }
             catch (err) {
                 process.exit(1);
             }
-        }));
+        });
     }
 }
 exports.StartCommand = StartCommand;

package/lib/compiler/assets-manager.js

@@ -67,9 +67,9 @@ class AssetsManager {
                 // prettier-ignore
                 const watcher = chokidar
                     .watch(item.glob, { ignored: item.exclude })
-                    .on('add', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'change' })))
-                    .on('change', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'change' })))
-                    .on('unlink', (path) => this.actionOnFile(Object.assign(Object.assign({}, option), { path, action: 'unlink' })));
+                    .on('add', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
+                    .on('change', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
+                    .on('unlink', (path) => this.actionOnFile({ ...option, path, action: 'unlink' }));
                 this.watchers.push(watcher);
             }
         }

package/lib/compiler/hooks/tsconfig-paths.hook.js

@@ -37,7 +37,7 @@ function tsconfigPathsBeforeHookFactory(compilerOptions) {
                             return updatedNode;
                         }
                     }
-                    catch (_a) {
+                    catch {
                         return node;
                     }
                 }
@@ -71,7 +71,7 @@ function getNotAliasedPath(sf, matcher, text) {
             return text;
         }
     }
-    catch (_a) { }
+    catch { }
     const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
     return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
 }

package/lib/compiler/interfaces/readonly-visitor.interface.d.ts

@@ -5,5 +5,5 @@ export type DeepPluginMeta = ts.ObjectLiteralExpression | {
 export interface ReadonlyVisitor {
     key: string;
     visit(program: ts.Program, sf: ts.SourceFile): void;
-    collect(): Array<[ts.CallExpression, DeepPluginMeta]>;
+    collect(): Record<string, Array<[ts.CallExpression, DeepPluginMeta]>>;
 }

package/lib/compiler/plugins/plugin-metadata-generator.d.ts

@@ -1,16 +1,56 @@
 import * as ts from 'typescript';
 import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
 export interface PluginMetadataGenerateOptions {
+    /**
+     * The visitors to use to generate the metadata.
+     */
     visitors: ReadonlyVisitor[];
+    /**
+     * The output directory to write the metadata to.
+     */
     outputDir: string;
+    /**
+     * Whether to watch the project for changes.
+     */
     watch?: boolean;
+    /**
+     * The path to the tsconfig file.
+     * Relative to the current working directory (process.cwd()).
+     */
     tsconfigPath?: string;
+    /**
+     * The filename to write the metadata to.
+     */
     filename?: string;
+    /**
+     * A reference to an existing ts.Program instance.
+     */
     tsProgramRef?: ts.Program;
+    /**
+     * Whether to print diagnostics to the console.
+     * @default true
+     */
+    printDiagnostics?: boolean;
 }
+/**
+ * Generates plugins metadata by traversing the AST of the project.
+ * @example
+ * ```ts
+ * const generator = new PluginMetadataGenerator();
+ * generator.generate({
+ *  visitors: [
+ *    new ReadonlyVisitor({ introspectComments: true, pathToSource: __dirname }),
+ *  ],
+ *  outputDir: __dirname,
+ *  watch: true,
+ *  tsconfigPath: 'tsconfig.build.json',
+ * });
+ * ```
+ */
 export declare class PluginMetadataGenerator {
     private readonly pluginMetadataPrinter;
     private readonly typeCheckerHost;
+    private readonly typescriptLoader;
     generate(options: PluginMetadataGenerateOptions): void;
     private traverseAndPrintMetadata;
 }

package/lib/compiler/plugins/plugin-metadata-generator.js

@@ -1,26 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginMetadataGenerator = void 0;
+const constants_1 = require("../swc/constants");
 const type_checker_host_1 = require("../swc/type-checker-host");
+const typescript_loader_1 = require("../typescript-loader");
 const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
+/**
+ * Generates plugins metadata by traversing the AST of the project.
+ * @example
+ * ```ts
+ * const generator = new PluginMetadataGenerator();
+ * generator.generate({
+ *  visitors: [
+ *    new ReadonlyVisitor({ introspectComments: true, pathToSource: __dirname }),
+ *  ],
+ *  outputDir: __dirname,
+ *  watch: true,
+ *  tsconfigPath: 'tsconfig.build.json',
+ * });
+ * ```
+ */
 class PluginMetadataGenerator {
     constructor() {
         this.pluginMetadataPrinter = new plugin_metadata_printer_1.PluginMetadataPrinter();
         this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
+        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
     }
     generate(options) {
-        const { tsconfigPath, visitors, tsProgramRef, outputDir, watch, filename } = options;
+        const { tsconfigPath, visitors, tsProgramRef, outputDir, watch, filename, printDiagnostics = true, } = options;
         if (visitors.length === 0) {
             return;
         }
         if (tsProgramRef) {
             return this.traverseAndPrintMetadata(tsProgramRef, visitors, outputDir, filename);
         }
+        const onTypeCheckOrProgramInit = (program) => {
+            this.traverseAndPrintMetadata(program, visitors, outputDir, filename);
+            if (printDiagnostics) {
+                const tsBinary = this.typescriptLoader.load();
+                const diagnostics = tsBinary.getPreEmitDiagnostics(program);
+                if (diagnostics.length > 0) {
+                    const formatDiagnosticsHost = {
+                        getCanonicalFileName: (path) => path,
+                        getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
+                        getNewLine: () => tsBinary.sys.newLine,
+                    };
+                    console.log();
+                    console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
+                }
+                else {
+                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                }
+            }
+        };
         this.typeCheckerHost.run(tsconfigPath, {
             watch,
-            onSuccess: (program) => {
-                this.traverseAndPrintMetadata(program, visitors, outputDir, filename);
-            },
+            onTypeCheck: onTypeCheckOrProgramInit,
+            onProgramInit: onTypeCheckOrProgramInit,
         });
     }
     traverseAndPrintMetadata(programRef, visitors, outputDir, filename) {

package/lib/compiler/plugins/plugin-metadata-printer.d.ts

@@ -4,7 +4,10 @@ export interface PluginMetadataPrintOptions {
     outputDir: string;
     filename?: string;
 }
+/**
+ * Prints the metadata to a file.
+ */
 export declare class PluginMetadataPrinter {
-    print(metadata: Record<string, Array<[ts.CallExpression, DeepPluginMeta]>>, options: PluginMetadataPrintOptions): void;
+    print(metadata: Record<string, Record<string, Array<[ts.CallExpression, DeepPluginMeta]>>>, options: PluginMetadataPrintOptions): void;
     private recursivelyCreatePropertyAssignment;
 }

package/lib/compiler/plugins/plugin-metadata-printer.js

@@ -5,22 +5,22 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const ts = require("typescript");
 const SERIALIZED_METADATA_FILENAME = 'metadata.ts';
+/**
+ * Prints the metadata to a file.
+ */
 class PluginMetadataPrinter {
     print(metadata, options) {
-        var _a;
         const objectLiteralExpr = ts.factory.createObjectLiteralExpression(Object.keys(metadata).map((key) => this.recursivelyCreatePropertyAssignment(key, metadata[key])));
-        const metadataCacheVariableStatement = ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('metadataCache'), undefined, undefined, objectLiteralExpr),
-        ], ts.NodeFlags.Const));
+        const exportAssignment = ts.factory.createExportAssignment(undefined, undefined, objectLiteralExpr);
         const printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,
         });
         const resultFile = ts.createSourceFile('file.ts', '', ts.ScriptTarget.Latest, 
         /*setParentNodes*/ false, ts.ScriptKind.TS);
-        const filename = (0, path_1.join)(options.outputDir, (_a = options.filename) !== null && _a !== void 0 ? _a : SERIALIZED_METADATA_FILENAME);
+        const filename = (0, path_1.join)(options.outputDir, options.filename ?? SERIALIZED_METADATA_FILENAME);
         const eslintPrefix = `/* eslint-disable */\n`;
         (0, fs_1.writeFileSync)(filename, eslintPrefix +
-            printer.printNode(ts.EmitHint.Unspecified, metadataCacheVariableStatement, resultFile));
+            printer.printNode(ts.EmitHint.Unspecified, exportAssignment, resultFile));
     }
     recursivelyCreatePropertyAssignment(identifier, meta) {
         if (Array.isArray(meta)) {

package/lib/compiler/plugins/plugins-loader.js

@@ -33,7 +33,11 @@ class PluginsLoader {
                 multiCompilerPlugins.afterDeclarationsHooks.push(plugin.afterDeclarations.bind(plugin.afterDeclarations, options));
             }
             if (plugin.ReadonlyVisitor) {
-                const instance = new plugin.ReadonlyVisitor(Object.assign(Object.assign(Object.assign({}, options), extras), { readonly: true }));
+                const instance = new plugin.ReadonlyVisitor({
+                    ...options,
+                    ...extras,
+                    readonly: true,
+                });
                 instance.key = pluginNames[index];
                 multiCompilerPlugins.readonlyVisitors.push(instance);
             }
@@ -53,7 +57,7 @@ class PluginsLoader {
                     });
                     return require(binaryPath);
                 }
-                catch (_a) { }
+                catch { }
                 const binaryPath = require.resolve(item, { paths: nodeModulePaths });
                 return require(binaryPath);
             }

package/lib/compiler/swc/forked-type-checker.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ui_1 = require("../../ui");
 const base_compiler_1 = require("../base-compiler");
@@ -22,32 +13,32 @@ class ForkedTypeChecker extends base_compiler_1.BaseCompiler {
         this.pluginMetadataGenerator = new plugin_metadata_generator_1.PluginMetadataGenerator();
         this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
     }
-    run(configuration, tsConfigPath, appName, extras) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { readonlyVisitors } = this.loadPlugins(configuration, tsConfigPath, appName);
-            const outputDir = this.getPathToSource(configuration, tsConfigPath, appName);
-            try {
-                this.typeCheckerHost.run(tsConfigPath, {
-                    watch: extras.watch,
-                    onSuccess: (program) => {
-                        if (readonlyVisitors.length > 0) {
-                            console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
-                            this.pluginMetadataGenerator.generate({
-                                outputDir,
-                                visitors: readonlyVisitors,
-                                tsProgramRef: program,
-                            });
-                        }
-                        else {
-                            console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED);
-                        }
-                    },
-                });
-            }
-            catch (err) {
-                console.log(ui_1.ERROR_PREFIX, err.message);
-            }
-        });
+    async run(configuration, tsConfigPath, appName, extras) {
+        const { readonlyVisitors } = this.loadPlugins(configuration, tsConfigPath, appName);
+        const outputDir = this.getPathToSource(configuration, tsConfigPath, appName);
+        try {
+            const onTypeCheckOrProgramInit = (program) => {
+                if (readonlyVisitors.length > 0) {
+                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                    this.pluginMetadataGenerator.generate({
+                        outputDir,
+                        visitors: readonlyVisitors,
+                        tsProgramRef: program,
+                    });
+                }
+                else {
+                    console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED);
+                }
+            };
+            this.typeCheckerHost.run(tsConfigPath, {
+                watch: extras.watch,
+                onTypeCheck: onTypeCheckOrProgramInit,
+                onProgramInit: onTypeCheckOrProgramInit,
+            });
+        }
+        catch (err) {
+            console.log(ui_1.ERROR_PREFIX, err.message);
+        }
     }
 }
 const pluginsLoader = new plugins_loader_1.PluginsLoader();

package/lib/compiler/swc/swc-compiler.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwcCompiler = void 0;
 const chalk = require("chalk");
@@ -27,38 +18,35 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
         this.pluginMetadataGenerator = new plugin_metadata_generator_1.PluginMetadataGenerator();
         this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
     }
-    run(configuration, tsConfigPath, appName, extras, onSuccess) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const swcOptions = (0, swc_defaults_1.swcDefaultsFactory)();
-            if (extras.watch) {
-                if (extras.typeCheck) {
-                    this.runTypeChecker(configuration, tsConfigPath, appName, extras);
-                }
-                yield this.runSwc(swcOptions, extras);
-                if (onSuccess) {
-                    onSuccess();
-                    const debounceTime = 150;
-                    const callback = this.debounce(onSuccess, debounceTime);
-                    this.watchFilesInOutDir(swcOptions, callback);
-                }
+    async run(configuration, tsConfigPath, appName, extras, onSuccess) {
+        const swcOptions = (0, swc_defaults_1.swcDefaultsFactory)();
+        if (extras.watch) {
+            if (extras.typeCheck) {
+                this.runTypeChecker(configuration, tsConfigPath, appName, extras);
             }
-            else {
-                if (extras.typeCheck) {
-                    yield this.runTypeChecker(configuration, tsConfigPath, appName, extras);
-                }
-                yield this.runSwc(swcOptions, extras);
-                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess();
+            await this.runSwc(swcOptions, extras);
+            if (onSuccess) {
+                onSuccess();
+                const debounceTime = 150;
+                const callback = this.debounce(onSuccess, debounceTime);
+                this.watchFilesInOutDir(swcOptions, callback);
             }
-        });
+        }
+        else {
+            if (extras.typeCheck) {
+                await this.runTypeChecker(configuration, tsConfigPath, appName, extras);
+            }
+            await this.runSwc(swcOptions, extras);
+            onSuccess?.();
+        }
     }
     runTypeChecker(configuration, tsConfigPath, appName, extras) {
-        var _a, _b;
         if (extras.watch) {
             const args = [
                 tsConfigPath,
                 appName,
-                (_a = configuration.sourceRoot) !== null && _a !== void 0 ? _a : 'src',
-                JSON.stringify((_b = configuration.compilerOptions.plugins) !== null && _b !== void 0 ? _b : []),
+                configuration.sourceRoot ?? 'src',
+                JSON.stringify(configuration.compilerOptions.plugins ?? []),
             ];
             (0, child_process_1.fork)((0, path_1.join)(__dirname, 'forked-type-checker.js'), args, {
                 cwd: process.cwd(),
@@ -72,7 +60,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
                 try {
                     this.typeCheckerHost.run(tsConfigPath, {
                         watch: extras.watch,
-                        onSuccess: (program) => {
+                        onTypeCheck: (program) => {
                             if (!fulfilled) {
                                 fulfilled = true;
                                 resolve();
@@ -100,13 +88,18 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
             });
         }
     }
-    runSwc(options, extras) {
-        return __awaiter(this, void 0, void 0, function* () {
-            process.nextTick(() => console.log(constants_1.SWC_LOG_PREFIX, chalk.cyan('Running...')));
-            const swcCli = this.loadSwcCliBinary();
-            const swcRcFile = yield this.getSwcRcFileContentIfExists();
-            const swcOptions = this.deepMerge(options.swcOptions, swcRcFile);
-            yield swcCli.default(Object.assign(Object.assign({}, options), { swcOptions, cliOptions: Object.assign(Object.assign({}, options.cliOptions), { watch: extras.watch }) }));
+    async runSwc(options, extras) {
+        process.nextTick(() => console.log(constants_1.SWC_LOG_PREFIX, chalk.cyan('Running...')));
+        const swcCli = this.loadSwcCliBinary();
+        const swcRcFile = await this.getSwcRcFileContentIfExists();
+        const swcOptions = this.deepMerge(options.swcOptions, swcRcFile);
+        await swcCli.default({
+            ...options,
+            swcOptions,
+            cliOptions: {
+                ...options.cliOptions,
+                watch: extras.watch,
+            },
         });
     }
     loadSwcCliBinary() {
@@ -134,7 +127,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
             source === null) {
             return source;
         }
-        const merged = Object.assign({}, target);
+        const merged = { ...target };
         for (const key in source) {
             if (source.hasOwnProperty(key)) {
                 if (key in target) {
@@ -164,7 +157,7 @@ class SwcCompiler extends base_compiler_1.BaseCompiler {
             },
         });
         for (const type of ['add', 'change']) {
-            watcher.on(type, () => __awaiter(this, void 0, void 0, function* () { return onChange(); }));
+            watcher.on(type, async () => onChange());
         }
     }
 }

package/lib/compiler/swc/type-checker-host.d.ts

@@ -1,7 +1,8 @@
 import * as ts from 'typescript';
 export interface TypeCheckerHostRunOptions {
     watch?: boolean;
-    onSuccess?: (program: ts.Program) => void;
+    onTypeCheck?: (program: ts.Program) => void;
+    onProgramInit?: (program: ts.Program) => void;
 }
 export declare class TypeCheckerHost {
     private readonly typescriptLoader;

package/lib/compiler/swc/type-checker-host.js

@@ -35,9 +35,8 @@ class TypeCheckerHost {
         const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(tsconfigPath);
         let builderProgram = undefined;
         const reportWatchStatusCallback = (diagnostic) => {
-            var _a, _b;
             if (diagnostic.messageText !== constants_1.TSC_NO_ERRORS_MESSAGE) {
-                if ((_a = diagnostic.messageText) === null || _a === void 0 ? void 0 : _a.includes('Found')) {
+                if (diagnostic.messageText?.includes('Found')) {
                     console.log(constants_1.TSC_LOG_ERROR_PREFIX, chalk.red(diagnostic.messageText));
                 }
                 return;
@@ -46,15 +45,17 @@ class TypeCheckerHost {
                 return;
             }
             const tsProgram = builderProgram.getProgram().getProgram();
-            (_b = options.onSuccess) === null || _b === void 0 ? void 0 : _b.call(options, tsProgram);
+            options.onTypeCheck?.(tsProgram);
         };
         const host = this.createWatchCompilerHost(tsBinary, tsconfigPath, tsOptions, reportWatchStatusCallback);
         builderProgram = tsBinary.createWatchProgram(host);
+        process.nextTick(() => {
+            options.onProgramInit?.(builderProgram.getProgram().getProgram());
+        });
     }
     runOnce(tsconfigPath, tsBinary, options) {
-        var _a, _b;
         const { options: tsOptions, fileNames, projectReferences, } = this.tsConfigProvider.getByConfigFilename(tsconfigPath);
-        const createProgram = (_a = tsBinary.createIncrementalProgram) !== null && _a !== void 0 ? _a : tsBinary.createProgram;
+        const createProgram = tsBinary.createIncrementalProgram ?? tsBinary.createProgram;
         const program = createProgram.call(ts, {
             rootNames: fileNames,
             projectReferences,
@@ -74,11 +75,15 @@ class TypeCheckerHost {
             console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
             process.exit(1);
         }
-        (_b = options.onSuccess) === null || _b === void 0 ? void 0 : _b.call(options, programRef);
+        options.onTypeCheck?.(programRef);
     }
     createWatchCompilerHost(tsBinary, tsConfigPath, options, reportWatchStatusCallback) {
         const origDiagnosticReporter = tsBinary.createDiagnosticReporter(tsBinary.sys, true);
-        const tsOptions = Object.assign(Object.assign({}, options), { preserveWatchOutput: true, noEmit: true });
+        const tsOptions = {
+            ...options,
+            preserveWatchOutput: true,
+            noEmit: true,
+        };
         return tsBinary.createWatchCompilerHost(tsConfigPath, tsOptions, tsBinary.sys, undefined, origDiagnosticReporter, reportWatchStatusCallback);
     }
 }

package/lib/compiler/typescript-loader.js

@@ -15,7 +15,7 @@ class TypeScriptBinaryLoader {
             this.tsBinary = tsBinary;
             return tsBinary;
         }
-        catch (_a) {
+        catch {
             throw new Error('TypeScript could not be found! Please, install "typescript" package.');
         }
     }

package/lib/compiler/watch-compiler.js

@@ -22,7 +22,10 @@ class WatchCompiler extends base_compiler_1.BaseCompiler {
         const createProgram = tsBin.createEmitAndSemanticDiagnosticsBuilderProgram;
         const origDiagnosticReporter = tsBin.createDiagnosticReporter(tsBin.sys, true);
         const origWatchStatusReporter = tsBin.createWatchStatusReporter(tsBin.sys, true);
-        const host = tsBin.createWatchCompilerHost(configPath, Object.assign(Object.assign({}, options), { preserveWatchOutput: extras.preserveWatchOutput }), tsBin.sys, createProgram, this.createDiagnosticReporter(origDiagnosticReporter), this.createWatchStatusChanged(origWatchStatusReporter, onSuccess));
+        const host = tsBin.createWatchCompilerHost(configPath, {
+            ...options,
+            preserveWatchOutput: extras.preserveWatchOutput,
+        }, tsBin.sys, createProgram, this.createDiagnosticReporter(origDiagnosticReporter), this.createWatchStatusChanged(origWatchStatusReporter, onSuccess));
         const manualRestart = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.manualRestart', appName);
         const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
         this.overrideCreateProgramFn(host, manualRestart, projectReferences, plugins);