@nestjs/cli 9.4.2 → 10.0.0-next.1

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginsLoader = void 0;
+const path_1 = require("path");
+const ui_1 = require("../../ui");
+const PLUGIN_ENTRY_FILENAME = 'plugin';
+class PluginsLoader {
+    load(plugins = [], extras = {}) {
+        const pluginNames = plugins.map((entry) => typeof entry === 'object'
+            ? entry.name
+            : entry);
+        const pluginRefs = this.resolvePluginReferences(pluginNames);
+        const multiCompilerPlugins = {
+            afterHooks: [],
+            afterDeclarationsHooks: [],
+            beforeHooks: [],
+            readonlyVisitors: [],
+        };
+        pluginRefs.forEach((plugin, index) => {
+            if (!plugin.before && !plugin.after && !plugin.afterDeclarations) {
+                throw new Error(ui_1.CLI_ERRORS.WRONG_PLUGIN(pluginNames[index]));
+            }
+            const options = typeof plugins[index] === 'object'
+                ? plugins[index].options || {}
+                : {};
+            if (plugin.before) {
+                multiCompilerPlugins.beforeHooks.push(plugin.before.bind(plugin.before, options));
+            }
+            if (plugin.after) {
+                multiCompilerPlugins.afterHooks.push(plugin.after.bind(plugin.after, options));
+            }
+            if (plugin.afterDeclarations) {
+                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 }));
+                instance.key = pluginNames[index];
+                multiCompilerPlugins.readonlyVisitors.push(instance);
+            }
+        });
+        return multiCompilerPlugins;
+    }
+    resolvePluginReferences(pluginNames) {
+        const nodeModulePaths = [
+            (0, path_1.join)(process.cwd(), 'node_modules'),
+            ...module.paths,
+        ];
+        return pluginNames.map((item) => {
+            try {
+                try {
+                    const binaryPath = require.resolve((0, path_1.join)(item, PLUGIN_ENTRY_FILENAME), {
+                        paths: nodeModulePaths,
+                    });
+                    return require(binaryPath);
+                }
+                catch (_a) { }
+                const binaryPath = require.resolve(item, { paths: nodeModulePaths });
+                return require(binaryPath);
+            }
+            catch (e) {
+                throw new Error(`"${item}" plugin is not installed.`);
+            }
+        });
+    }
+}
+exports.PluginsLoader = PluginsLoader;

package/lib/compiler/swc/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const TSC_NO_ERRORS_MESSAGE = "Found 0 errors. Watching for file changes.";
+export declare const TSC_COMPILATION_STARTED_MESSAGE = "Starting compilation in watch mode...";
+export declare const SWC_LOG_PREFIX: string;
+export declare const TSC_LOG_PREFIX: string;
+export declare const TSC_LOG_ERROR_PREFIX: string;
+export declare const TSC_LOG_SUCCESS_PREFIX: string;
+export declare const INITIALIZING_TYPE_CHECKER: string;
+export declare const FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED: string;
+export declare const FOUND_NO_ISSUES_GENERATING_METADATA: string;

package/lib/compiler/swc/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOUND_NO_ISSUES_GENERATING_METADATA = exports.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED = exports.INITIALIZING_TYPE_CHECKER = exports.TSC_LOG_SUCCESS_PREFIX = exports.TSC_LOG_ERROR_PREFIX = exports.TSC_LOG_PREFIX = exports.SWC_LOG_PREFIX = exports.TSC_COMPILATION_STARTED_MESSAGE = exports.TSC_NO_ERRORS_MESSAGE = void 0;
+const chalk = require("chalk");
+exports.TSC_NO_ERRORS_MESSAGE = 'Found 0 errors. Watching for file changes.';
+exports.TSC_COMPILATION_STARTED_MESSAGE = 'Starting compilation in watch mode...';
+exports.SWC_LOG_PREFIX = chalk.cyan('> ') + chalk.bgCyan.bold(' SWC ');
+exports.TSC_LOG_PREFIX = chalk.cyan('> ') + chalk.bgCyan.bold(' TSC ');
+exports.TSC_LOG_ERROR_PREFIX = chalk.red('> ') + chalk.bgRed.bold(' TSC ');
+exports.TSC_LOG_SUCCESS_PREFIX = chalk.green('> ') + chalk.bgGreen.bold(' TSC ');
+exports.INITIALIZING_TYPE_CHECKER = chalk.bgCyan.bold(' TSC ') + chalk.cyan(' Initializing type checker...');
+exports.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED = exports.TSC_LOG_SUCCESS_PREFIX + chalk.green(' Found 0 issues.');
+exports.FOUND_NO_ISSUES_GENERATING_METADATA = exports.TSC_LOG_SUCCESS_PREFIX +
+    chalk.green(' Found 0 issues. Generating metadata...');

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,72 @@
+"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");
+const plugin_metadata_generator_1 = require("../plugins/plugin-metadata-generator");
+const plugins_loader_1 = require("../plugins/plugins-loader");
+const constants_1 = require("./constants");
+const type_checker_host_1 = require("./type-checker-host");
+const [tsConfigPath, appName, sourceRoot, plugins] = process.argv.slice(2);
+class ForkedTypeChecker extends base_compiler_1.BaseCompiler {
+    constructor() {
+        super(...arguments);
+        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);
+            }
+        });
+    }
+}
+const pluginsLoader = new plugins_loader_1.PluginsLoader();
+const forkedTypeChecker = new ForkedTypeChecker(pluginsLoader);
+const applicationName = appName === 'undefined' ? '' : appName;
+const options = {
+    sourceRoot,
+};
+if (applicationName) {
+    options.projects = {};
+    options.projects[applicationName] = {
+        compilerOptions: {
+            plugins: JSON.parse(plugins),
+        },
+    };
+}
+else {
+    options.compilerOptions = {
+        plugins: JSON.parse(plugins),
+    };
+}
+forkedTypeChecker.run(options, tsConfigPath, applicationName, { watch: true, typeCheck: true });

package/lib/compiler/swc/swc-compiler.d.ts

@@ -0,0 +1,20 @@
+import { Configuration } from '../../configuration';
+import { BaseCompiler } from '../base-compiler';
+import { PluginsLoader } from '../plugins/plugins-loader';
+export type SwcCompilerExtras = {
+    watch: boolean;
+    typeCheck: boolean;
+};
+export declare class SwcCompiler extends BaseCompiler {
+    private readonly pluginMetadataGenerator;
+    private readonly typeCheckerHost;
+    constructor(pluginsLoader: PluginsLoader);
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string, extras: SwcCompilerExtras, onSuccess?: () => void): Promise<void>;
+    private runTypeChecker;
+    private runSwc;
+    private loadSwcCliBinary;
+    private getSwcRcFileContentIfExists;
+    private deepMerge;
+    private debounce;
+    private watchFilesInOutDir;
+}

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

@@ -0,0 +1,171 @@
+"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");
+const child_process_1 = require("child_process");
+const chokidar = require("chokidar");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ui_1 = require("../../ui");
+const base_compiler_1 = require("../base-compiler");
+const swc_defaults_1 = require("../defaults/swc-defaults");
+const plugin_metadata_generator_1 = require("../plugins/plugin-metadata-generator");
+const constants_1 = require("./constants");
+const type_checker_host_1 = require("./type-checker-host");
+class SwcCompiler extends base_compiler_1.BaseCompiler {
+    constructor(pluginsLoader) {
+        super(pluginsLoader);
+        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);
+                }
+            }
+            else {
+                if (extras.typeCheck) {
+                    yield this.runTypeChecker(configuration, tsConfigPath, appName, extras);
+                }
+                yield this.runSwc(swcOptions, extras);
+                onSuccess === null || onSuccess === void 0 ? void 0 : 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 : []),
+            ];
+            (0, child_process_1.fork)((0, path_1.join)(__dirname, 'forked-type-checker.js'), args, {
+                cwd: process.cwd(),
+            });
+        }
+        else {
+            const { readonlyVisitors } = this.loadPlugins(configuration, tsConfigPath, appName);
+            const outputDir = this.getPathToSource(configuration, tsConfigPath, appName);
+            let fulfilled = false;
+            return new Promise((resolve, reject) => {
+                try {
+                    this.typeCheckerHost.run(tsConfigPath, {
+                        watch: extras.watch,
+                        onSuccess: (program) => {
+                            if (!fulfilled) {
+                                fulfilled = true;
+                                resolve();
+                            }
+                            if (readonlyVisitors.length > 0) {
+                                process.nextTick(() => console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA));
+                                this.pluginMetadataGenerator.generate({
+                                    outputDir,
+                                    visitors: readonlyVisitors,
+                                    tsProgramRef: program,
+                                });
+                            }
+                            else {
+                                process.nextTick(() => console.log(constants_1.FOUND_NO_ISSUES_METADATA_GENERATION_SKIPPED));
+                            }
+                        },
+                    });
+                }
+                catch (err) {
+                    if (!fulfilled) {
+                        fulfilled = true;
+                        reject(err);
+                    }
+                }
+            });
+        }
+    }
+    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 }) }));
+        });
+    }
+    loadSwcCliBinary() {
+        try {
+            return require('@swc/cli/lib/swc/dir');
+        }
+        catch (err) {
+            console.error(ui_1.ERROR_PREFIX +
+                ' Failed to load "@swc/cli" package. Please, install it by running "npm i -D @swc/cli"');
+            throw err;
+        }
+    }
+    getSwcRcFileContentIfExists() {
+        try {
+            return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), '.swcrc'), 'utf8'));
+        }
+        catch (err) {
+            return {};
+        }
+    }
+    deepMerge(target, source) {
+        if (typeof target !== 'object' ||
+            target === null ||
+            typeof source !== 'object' ||
+            source === null) {
+            return source;
+        }
+        const merged = Object.assign({}, target);
+        for (const key in source) {
+            if (source.hasOwnProperty(key)) {
+                if (key in target) {
+                    merged[key] = this.deepMerge(target[key], source[key]);
+                }
+                else {
+                    merged[key] = source[key];
+                }
+            }
+        }
+        return merged;
+    }
+    debounce(callback, wait) {
+        let timeout;
+        return () => {
+            clearTimeout(timeout);
+            timeout = setTimeout(callback, wait);
+        };
+    }
+    watchFilesInOutDir(options, onChange) {
+        const outDir = (0, path_1.join)(process.cwd(), options.cliOptions.outDir, '**/*.js');
+        const watcher = chokidar.watch(outDir, {
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+                pollInterval: 10,
+            },
+        });
+        for (const type of ['add', 'change']) {
+            watcher.on(type, () => __awaiter(this, void 0, void 0, function* () { return onChange(); }));
+        }
+    }
+}
+exports.SwcCompiler = SwcCompiler;

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

@@ -0,0 +1,13 @@
+import * as ts from 'typescript';
+export interface TypeCheckerHostRunOptions {
+    watch?: boolean;
+    onSuccess?: (program: ts.Program) => void;
+}
+export declare class TypeCheckerHost {
+    private readonly typescriptLoader;
+    private readonly tsConfigProvider;
+    run(tsconfigPath: string | undefined, options: TypeCheckerHostRunOptions): void;
+    private runInWatchMode;
+    private runOnce;
+    private createWatchCompilerHost;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeCheckerHost = void 0;
+const chalk = require("chalk");
+const ora = require("ora");
+const ts = require("typescript");
+const tsconfig_provider_1 = require("../helpers/tsconfig-provider");
+const typescript_loader_1 = require("../typescript-loader");
+const constants_1 = require("./constants");
+class TypeCheckerHost {
+    constructor() {
+        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
+        this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.typescriptLoader);
+    }
+    run(tsconfigPath, options) {
+        if (!tsconfigPath) {
+            throw new Error('"tsconfigPath" is required when "tsProgramRef" is not provided.');
+        }
+        const tsBinary = this.typescriptLoader.load();
+        const spinner = ora({
+            text: constants_1.INITIALIZING_TYPE_CHECKER,
+        });
+        if (options.watch) {
+            console.log();
+            spinner.start();
+            this.runInWatchMode(tsconfigPath, tsBinary, options);
+            spinner.succeed();
+            return;
+        }
+        spinner.start();
+        this.runOnce(tsconfigPath, tsBinary, options);
+        spinner.succeed();
+    }
+    runInWatchMode(tsconfigPath, tsBinary, options) {
+        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')) {
+                    console.log(constants_1.TSC_LOG_ERROR_PREFIX, chalk.red(diagnostic.messageText));
+                }
+                return;
+            }
+            if (!builderProgram) {
+                return;
+            }
+            const tsProgram = builderProgram.getProgram().getProgram();
+            (_b = options.onSuccess) === null || _b === void 0 ? void 0 : _b.call(options, tsProgram);
+        };
+        const host = this.createWatchCompilerHost(tsBinary, tsconfigPath, tsOptions, reportWatchStatusCallback);
+        builderProgram = tsBinary.createWatchProgram(host);
+    }
+    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 program = createProgram.call(ts, {
+            rootNames: fileNames,
+            projectReferences,
+            options: tsOptions,
+        });
+        const programRef = program.getProgram
+            ? program.getProgram()
+            : program;
+        const diagnostics = tsBinary.getPreEmitDiagnostics(programRef);
+        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));
+            process.exit(1);
+        }
+        (_b = options.onSuccess) === null || _b === void 0 ? void 0 : _b.call(options, programRef);
+    }
+    createWatchCompilerHost(tsBinary, tsConfigPath, options, reportWatchStatusCallback) {
+        const origDiagnosticReporter = tsBinary.createDiagnosticReporter(tsBinary.sys, true);
+        const tsOptions = Object.assign(Object.assign({}, options), { preserveWatchOutput: true, noEmit: true });
+        return tsBinary.createWatchCompilerHost(tsConfigPath, tsOptions, tsBinary.sys, undefined, origDiagnosticReporter, reportWatchStatusCallback);
+    }
+}
+exports.TypeCheckerHost = TypeCheckerHost;

package/lib/compiler/watch-compiler.d.ts

@@ -1,14 +1,18 @@
-import * as ts from 'typescript';
 import { Configuration } from '../configuration';
+import { BaseCompiler } from './base-compiler';
 import { TsConfigProvider } from './helpers/tsconfig-provider';
-import { PluginsLoader } from './plugins-loader';
+import { PluginsLoader } from './plugins/plugins-loader';
 import { TypeScriptBinaryLoader } from './typescript-loader';
-export declare class WatchCompiler {
-    private readonly pluginsLoader;
+type TypescriptWatchCompilerExtras = {
+    preserveWatchOutput: boolean;
+};
+export declare class WatchCompiler extends BaseCompiler<TypescriptWatchCompilerExtras> {
     private readonly tsConfigProvider;
     private readonly typescriptLoader;
     constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
-    run(configuration: Required<Configuration>, configFilename: string, appName: string, tsCompilerOptions: ts.CompilerOptions, onSuccess?: () => void): void;
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string, extras: TypescriptWatchCompilerExtras, onSuccess?: () => void): void;
+    private overrideCreateProgramFn;
     private createDiagnosticReporter;
     private createWatchStatusChanged;
 }
+export {};

package/lib/compiler/watch-compiler.js

@@ -2,33 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WatchCompiler = void 0;
 const errors_1 = require("../ui/errors");
+const base_compiler_1 = require("./base-compiler");
 const get_value_or_default_1 = require("./helpers/get-value-or-default");
 const manual_restart_1 = require("./helpers/manual-restart");
 const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
-class WatchCompiler {
+class WatchCompiler extends base_compiler_1.BaseCompiler {
     constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
-        this.pluginsLoader = pluginsLoader;
+        super(pluginsLoader);
         this.tsConfigProvider = tsConfigProvider;
         this.typescriptLoader = typescriptLoader;
     }
-    run(configuration, configFilename, appName, tsCompilerOptions, onSuccess) {
+    run(configuration, tsConfigPath, appName, extras, onSuccess) {
         const tsBin = this.typescriptLoader.load();
-        const configPath = tsBin.findConfigFile(process.cwd(), tsBin.sys.fileExists, configFilename);
+        const configPath = tsBin.findConfigFile(process.cwd(), tsBin.sys.fileExists, tsConfigPath);
         if (!configPath) {
-            throw new Error(errors_1.CLI_ERRORS.MISSING_TYPESCRIPT(configFilename));
+            throw new Error(errors_1.CLI_ERRORS.MISSING_TYPESCRIPT(tsConfigPath));
         }
-        const { options, projectReferences } = this.tsConfigProvider.getByConfigFilename(configFilename);
+        const { options, projectReferences } = this.tsConfigProvider.getByConfigFilename(tsConfigPath);
         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), tsCompilerOptions), tsBin.sys, createProgram, this.createDiagnosticReporter(origDiagnosticReporter), this.createWatchStatusChanged(origWatchStatusReporter, onSuccess));
-        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
-        const plugins = this.pluginsLoader.load(pluginsConfig);
+        const host = tsBin.createWatchCompilerHost(configPath, Object.assign(Object.assign({}, 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);
+        const watchProgram = tsBin.createWatchProgram(host);
+        if (manualRestart) {
+            (0, manual_restart_1.listenForManualRestart)(() => {
+                watchProgram.close();
+                this.run(configuration, tsConfigPath, appName, extras, onSuccess);
+            });
+        }
+    }
+    overrideCreateProgramFn(host, manualRestart, projectReferences, plugins) {
         const origCreateProgram = host.createProgram;
         host.createProgram = (rootNames, options, 
         // tslint:disable-next-line:no-shadowed-variable
         host, oldProgram) => {
-            (0, manual_restart_1.displayManualRestartTip)();
+            if (manualRestart) {
+                (0, manual_restart_1.displayManualRestartTip)();
+            }
             const tsconfigPathsPlugin = options
                 ? (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options)
                 : null;
@@ -50,11 +63,6 @@ class WatchCompiler {
             };
             return program;
         };
-        const watchProgram = tsBin.createWatchProgram(host);
-        (0, manual_restart_1.listenForManualRestart)(() => {
-            watchProgram.close();
-            this.run(configuration, configFilename, appName, tsCompilerOptions, onSuccess);
-        });
     }
     createDiagnosticReporter(diagnosticReporter) {
         return function (diagnostic, ...args) {

package/lib/compiler/webpack-compiler.d.ts

@@ -1,13 +1,21 @@
+import { Input } from '../../commands';
 import { Configuration } from '../configuration';
 import { AssetsManager } from './assets-manager';
-import { PluginsLoader } from './plugins-loader';
-import { Input } from '../../commands';
+import { BaseCompiler } from './base-compiler';
+import { PluginsLoader } from './plugins/plugins-loader';
 import webpack = require('webpack');
 type WebpackConfigFactory = (config: webpack.Configuration, webpackRef: typeof webpack) => webpack.Configuration;
 type WebpackConfigFactoryOrConfig = WebpackConfigFactory | webpack.Configuration;
-export declare class WebpackCompiler {
-    private readonly pluginsLoader;
+type WebpackCompilerExtras = {
+    inputs: Input[];
+    assetsManager: AssetsManager;
+    webpackConfigFactoryOrConfig: WebpackConfigFactoryOrConfig | WebpackConfigFactoryOrConfig[];
+    debug?: boolean;
+    watchMode?: boolean;
+};
+export declare class WebpackCompiler extends BaseCompiler<WebpackCompilerExtras> {
     constructor(pluginsLoader: PluginsLoader);
-    run(configuration: Required<Configuration>, options: Input[], webpackConfigFactoryOrConfig: WebpackConfigFactoryOrConfig | WebpackConfigFactoryOrConfig[], tsConfigPath: string, appName: string, isDebugEnabled: boolean | undefined, watchMode: boolean | undefined, assetsManager: AssetsManager, onSuccess?: () => void): void;
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string, extras: WebpackCompilerExtras, onSuccess?: () => void): void;
+    private createAfterCallback;
 }
 export {};