@depup/nestjs__cli 11.0.16-depup.1

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwcCompiler = void 0;
+const ansis_1 = require("ansis");
+const child_process_1 = require("child_process");
+const chokidar = require("chokidar");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path = require("path");
+const path_1 = require("path");
+const ui_1 = require("../../ui");
+const tree_kill_1 = require("../../utils/tree-kill");
+const base_compiler_1 = require("../base-compiler");
+const swc_defaults_1 = require("../defaults/swc-defaults");
+const get_value_or_default_1 = require("../helpers/get-value-or-default");
+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();
+    }
+    async run(configuration, tsConfigPath, appName, extras, onSuccess) {
+        const swcOptions = (0, swc_defaults_1.swcDefaultsFactory)(extras.tsOptions, configuration);
+        const swcrcFilePath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder.options.swcrcPath', appName);
+        if (extras.watch) {
+            if (extras.typeCheck) {
+                this.runTypeChecker(configuration, tsConfigPath, appName, extras);
+            }
+            await this.runSwc(swcOptions, extras, swcrcFilePath);
+            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, swcrcFilePath);
+            if (onSuccess) {
+                onSuccess();
+            }
+            extras.assetsManager?.closeWatchers();
+        }
+    }
+    runTypeChecker(configuration, tsConfigPath, appName, extras) {
+        if (extras.watch) {
+            const args = [
+                tsConfigPath,
+                appName ?? 'undefined',
+                configuration.sourceRoot ?? 'src',
+                JSON.stringify(configuration.compilerOptions.plugins ?? []),
+            ];
+            const childProcessRef = (0, child_process_1.fork)((0, path_1.join)(__dirname, 'forked-type-checker.js'), args, {
+                cwd: process.cwd(),
+            });
+            process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+        }
+        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,
+                        onTypeCheck: (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);
+                    }
+                }
+            });
+        }
+    }
+    async runSwc(options, extras, swcrcFilePath) {
+        process.nextTick(() => console.log(constants_1.SWC_LOG_PREFIX, (0, ansis_1.cyan)('Running...')));
+        const swcCli = this.loadSwcCliBinary();
+        const swcRcFile = await this.getSwcRcFileContentIfExists(swcrcFilePath);
+        const swcOptions = this.deepMerge(options.swcOptions, swcRcFile);
+        if (swcOptions?.jsc?.baseUrl && !(0, path_1.isAbsolute)(swcOptions?.jsc?.baseUrl)) {
+            // jsc.baseUrl should be resolved by the caller, if it's passed as an object.
+            // https://github.com/swc-project/swc/pull/7827
+            const rootDir = process.cwd();
+            swcOptions.jsc.baseUrl = path.join(rootDir, swcOptions.jsc.baseUrl);
+        }
+        const swcCliOpts = {
+            ...options,
+            swcOptions,
+            cliOptions: {
+                ...options.cliOptions,
+                watch: extras.watch,
+            },
+        };
+        if (extras.watch) {
+            // This is required since SWC no longer supports auto-compiling of newly added files in watch mode.
+            // We need to watch the source directory and trigger SWC compilation manually.
+            await this.watchFilesInSrcDir(options, async (file) => {
+                // Transpile newly added file
+                await swcCli.default({
+                    ...swcCliOpts,
+                    cliOptions: {
+                        ...swcCliOpts.cliOptions,
+                        filenames: [file],
+                    },
+                });
+            });
+        }
+        await swcCli.default(swcCliOpts);
+    }
+    loadSwcCliBinary() {
+        try {
+            return require('@swc/cli/lib/swc/dir');
+        }
+        catch (err) {
+            console.error(ui_1.ERROR_PREFIX +
+                ' Failed to load "@swc/cli" and/or "@swc/core" required packages. Please, make sure to install them as development dependencies.');
+            process.exit(1);
+        }
+    }
+    getSwcRcFileContentIfExists(swcrcFilePath) {
+        try {
+            return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), swcrcFilePath ?? '.swcrc'), 'utf8'));
+        }
+        catch (err) {
+            if (swcrcFilePath !== undefined) {
+                console.error(ui_1.ERROR_PREFIX +
+                    ` Failed to load "${swcrcFilePath}". Please, check if the file exists and is valid JSON.`);
+                process.exit(1);
+            }
+            return {};
+        }
+    }
+    deepMerge(target, source) {
+        if (typeof target !== 'object' ||
+            target === null ||
+            typeof source !== 'object' ||
+            source === null) {
+            return source;
+        }
+        if (Array.isArray(target) && Array.isArray(source)) {
+            return source.reduce((acc, value, index) => {
+                acc[index] = this.deepMerge(target[index], value);
+                return acc;
+            }, target);
+        }
+        const merged = { ...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);
+        };
+    }
+    async watchFilesInSrcDir(options, onFileAdded) {
+        const srcDir = options.cliOptions?.filenames?.[0];
+        const isDirectory = await (0, promises_1.stat)(srcDir)
+            .then((stats) => stats.isDirectory())
+            .catch(() => false);
+        if (!srcDir || !isDirectory) {
+            // Skip watching if source directory is not a default "src" folder
+            // or any other specified directory
+            return;
+        }
+        const extensions = options.cliOptions?.extensions ?? ['ts'];
+        const watcher = chokidar.watch(srcDir, {
+            ignored: (file, stats) => (stats?.isFile() &&
+                extensions.includes(path.extname(file).slice(1))),
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+                pollInterval: 10,
+            },
+        });
+        watcher.on('add', async (file) => onFileAdded(file));
+    }
+    watchFilesInOutDir(options, onChange) {
+        const dir = (0, path_1.isAbsolute)(options.cliOptions.outDir)
+            ? options.cliOptions.outDir
+            : (0, path_1.join)(process.cwd(), options.cliOptions.outDir);
+        const watcher = chokidar.watch(dir, {
+            ignored: (file, stats) => (stats?.isFile() &&
+                !(file.endsWith('.js') || file.endsWith('.mjs'))),
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+                pollInterval: 10,
+            },
+        });
+        for (const type of ['add', 'change']) {
+            watcher.on(type, async () => onChange());
+        }
+    }
+}
+exports.SwcCompiler = SwcCompiler;

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

@@ -0,0 +1,14 @@
+import * as ts from 'typescript';
+export interface TypeCheckerHostRunOptions {
+    watch?: boolean;
+    onTypeCheck?: (program: ts.Program) => void;
+    onProgramInit?: (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,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeCheckerHost = void 0;
+const ansis_1 = require("ansis");
+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) => {
+            if (diagnostic.messageText !== constants_1.TSC_NO_ERRORS_MESSAGE) {
+                if (diagnostic.messageText?.includes('Found')) {
+                    console.log(constants_1.TSC_LOG_ERROR_PREFIX, (0, ansis_1.red)(diagnostic.messageText.toString()));
+                }
+                return;
+            }
+            if (!builderProgram) {
+                return;
+            }
+            const tsProgram = builderProgram.getProgram().getProgram();
+            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) {
+        const { options: tsOptions, fileNames, projectReferences, } = this.tsConfigProvider.getByConfigFilename(tsconfigPath);
+        const createProgram = tsBinary.createIncrementalProgram ?? 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);
+        }
+        options.onTypeCheck?.(programRef);
+    }
+    createWatchCompilerHost(tsBinary, tsConfigPath, options, reportWatchStatusCallback) {
+        const origDiagnosticReporter = tsBinary.createDiagnosticReporter(tsBinary.sys, true);
+        const tsOptions = {
+            ...options,
+            preserveWatchOutput: true,
+            noEmit: true,
+        };
+        return tsBinary.createWatchCompilerHost(tsConfigPath, tsOptions, tsBinary.sys, undefined, origDiagnosticReporter, reportWatchStatusCallback);
+    }
+}
+exports.TypeCheckerHost = TypeCheckerHost;

package/lib/compiler/typescript-loader.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+export declare class TypeScriptBinaryLoader {
+    private tsBinary?;
+    load(): typeof ts;
+    getModulePaths(): string[];
+}

package/lib/compiler/typescript-loader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptBinaryLoader = void 0;
+class TypeScriptBinaryLoader {
+    load() {
+        if (this.tsBinary) {
+            return this.tsBinary;
+        }
+        try {
+            const tsBinaryPath = require.resolve('typescript', {
+                paths: [process.cwd(), ...this.getModulePaths()],
+            });
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const tsBinary = require(tsBinaryPath);
+            this.tsBinary = tsBinary;
+            return tsBinary;
+        }
+        catch {
+            throw new Error('TypeScript could not be found! Please, install "typescript" package.');
+        }
+    }
+    getModulePaths() {
+        const modulePaths = module.paths.slice(2, module.paths.length);
+        const packageDeps = modulePaths.slice(0, 3);
+        return [
+            ...packageDeps.reverse(),
+            ...modulePaths.slice(3, modulePaths.length).reverse(),
+        ];
+    }
+}
+exports.TypeScriptBinaryLoader = TypeScriptBinaryLoader;

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

@@ -0,0 +1,22 @@
+import { Configuration } from '../configuration';
+import { BaseCompiler } from './base-compiler';
+import { TsConfigProvider } from './helpers/tsconfig-provider';
+import { PluginsLoader } from './plugins/plugins-loader';
+import { TypeScriptBinaryLoader } from './typescript-loader';
+type TypescriptWatchCompilerExtras = {
+    /**
+     * If `undefined`, the value of 'preserveWatchOutput' option from tsconfig
+     * file will be used instead.
+     */
+    preserveWatchOutput: boolean | undefined;
+};
+export declare class WatchCompiler extends BaseCompiler<TypescriptWatchCompilerExtras> {
+    private readonly tsConfigProvider;
+    private readonly typescriptLoader;
+    constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras: TypescriptWatchCompilerExtras, onSuccess?: () => void): void;
+    private overrideCreateProgramFn;
+    private createDiagnosticReporter;
+    private createWatchStatusChanged;
+}
+export {};

package/lib/compiler/watch-compiler.js

@@ -0,0 +1,89 @@
+"use strict";
+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 extends base_compiler_1.BaseCompiler {
+    constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
+        super(pluginsLoader);
+        this.tsConfigProvider = tsConfigProvider;
+        this.typescriptLoader = typescriptLoader;
+    }
+    run(configuration, tsConfigPath, appName, extras, onSuccess) {
+        const tsBin = this.typescriptLoader.load();
+        const configPath = tsBin.findConfigFile(process.cwd(), tsBin.sys.fileExists, tsConfigPath);
+        if (!configPath) {
+            throw new Error(errors_1.CLI_ERRORS.MISSING_TYPESCRIPT(tsConfigPath));
+        }
+        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, {
+            ...options,
+            preserveWatchOutput: extras.preserveWatchOutput ?? options.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) => {
+            if (manualRestart) {
+                (0, manual_restart_1.displayManualRestartTip)();
+            }
+            const tsconfigPathsPlugin = options
+                ? (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options)
+                : null;
+            const program = origCreateProgram(rootNames, options, host, oldProgram, undefined, projectReferences);
+            const origProgramEmit = program.emit;
+            program.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+                let transforms = customTransformers;
+                transforms = typeof transforms !== 'object' ? {} : transforms;
+                const before = plugins.beforeHooks.map((hook) => hook(program.getProgram()));
+                const after = plugins.afterHooks.map((hook) => hook(program.getProgram()));
+                const afterDeclarations = plugins.afterDeclarationsHooks.map((hook) => hook(program.getProgram()));
+                if (tsconfigPathsPlugin) {
+                    before.unshift(tsconfigPathsPlugin);
+                }
+                transforms.before = before.concat(transforms.before || []);
+                transforms.after = after.concat(transforms.after || []);
+                transforms.afterDeclarations = afterDeclarations.concat(transforms.afterDeclarations || []);
+                return origProgramEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, transforms);
+            };
+            return program;
+        };
+    }
+    createDiagnosticReporter(diagnosticReporter) {
+        return function (diagnostic, ...args) {
+            return diagnosticReporter.call(this, diagnostic, ...args);
+        };
+    }
+    createWatchStatusChanged(watchStatusReporter, onSuccess) {
+        return function (diagnostic, ...args) {
+            const messageText = diagnostic && diagnostic.messageText;
+            const noErrorsMessage = '0 errors';
+            if (messageText &&
+                messageText.includes &&
+                messageText.includes(noErrorsMessage) &&
+                onSuccess) {
+                onSuccess();
+            }
+            return watchStatusReporter.call(this, diagnostic, ...args);
+        };
+    }
+}
+exports.WatchCompiler = WatchCompiler;

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

@@ -0,0 +1,21 @@
+import { Input } from '../../commands';
+import { Configuration } from '../configuration';
+import { AssetsManager } from './assets-manager';
+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;
+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>, tsConfigPath: string, appName: string | undefined, extras: WebpackCompilerExtras, onSuccess?: () => void): void;
+    private createAfterCallback;
+}
+export {};

package/lib/compiler/webpack-compiler.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpackCompiler = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ui_1 = require("../ui");
+const base_compiler_1 = require("./base-compiler");
+const webpack_defaults_1 = require("./defaults/webpack-defaults");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+const webpack = require("webpack");
+class WebpackCompiler extends base_compiler_1.BaseCompiler {
+    constructor(pluginsLoader) {
+        super(pluginsLoader);
+    }
+    run(configuration, tsConfigPath, appName, extras, onSuccess) {
+        const cwd = process.cwd();
+        const configPath = (0, path_1.join)(cwd, tsConfigPath);
+        if (!(0, fs_1.existsSync)(configPath)) {
+            throw new Error(`Could not find TypeScript configuration file "${tsConfigPath}".`);
+        }
+        const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
+        const pathToSource = this.getPathToSource(configuration, tsConfigPath, appName);
+        const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName, 'entryFile', extras.inputs);
+        const entryFileRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'root', appName) || '';
+        const defaultOptions = (0, webpack_defaults_1.webpackDefaultsFactory)(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, tsConfigPath, plugins);
+        let compiler;
+        let watchOptions;
+        let watch;
+        if (Array.isArray(extras.webpackConfigFactoryOrConfig)) {
+            const webpackConfigurations = extras.webpackConfigFactoryOrConfig.map((configOrFactory) => {
+                const unwrappedConfig = typeof configOrFactory !== 'function'
+                    ? configOrFactory
+                    : configOrFactory(defaultOptions, webpack);
+                return {
+                    ...defaultOptions,
+                    mode: extras.watchMode ? 'development' : defaultOptions.mode,
+                    ...unwrappedConfig,
+                };
+            });
+            compiler = webpack(webpackConfigurations);
+            watchOptions = webpackConfigurations.map((config) => config.watchOptions || {});
+            watch = webpackConfigurations.some((config) => config.watch);
+        }
+        else {
+            const projectWebpackOptions = typeof extras.webpackConfigFactoryOrConfig !== 'function'
+                ? extras.webpackConfigFactoryOrConfig
+                : extras.webpackConfigFactoryOrConfig(defaultOptions, webpack);
+            const webpackConfiguration = {
+                ...defaultOptions,
+                mode: extras.watchMode ? 'development' : defaultOptions.mode,
+                ...projectWebpackOptions,
+            };
+            compiler = webpack(webpackConfiguration);
+            watchOptions = webpackConfiguration.watchOptions;
+            watch = webpackConfiguration.watch;
+        }
+        const afterCallback = this.createAfterCallback(onSuccess, extras.assetsManager, extras.watchMode ?? false, watch);
+        if (extras.watchMode || watch) {
+            compiler.hooks.watchRun.tapAsync('Rebuild info', (params, callback) => {
+                console.log(`\n${ui_1.INFO_PREFIX} Webpack is building your sources...\n`);
+                callback();
+            });
+            compiler.watch(watchOptions || {}, afterCallback);
+        }
+        else {
+            compiler.run(afterCallback);
+        }
+    }
+    createAfterCallback(onSuccess, assetsManager, watchMode, watch) {
+        return (err, stats) => {
+            if (err && stats === undefined) {
+                // Could not complete the compilation
+                // The error caught is most likely thrown by underlying tasks
+                console.log(err);
+                return process.exit(1);
+            }
+            const statsOutput = stats.toString({
+                chunks: false,
+                colors: true,
+                modules: false,
+                assets: false,
+            });
+            if (!err && !stats.hasErrors()) {
+                if (!onSuccess) {
+                    assetsManager.closeWatchers();
+                }
+                else {
+                    onSuccess();
+                }
+            }
+            else if (!watchMode && !watch) {
+                console.log(statsOutput);
+                return process.exit(1);
+            }
+            console.log(statsOutput);
+        };
+    }
+}
+exports.WebpackCompiler = WebpackCompiler;