@depup/nestjs__cli 11.0.24-depup.7 → 12.0.0-depup.0

package/README.md

@@ -13,27 +13,19 @@ npm install @depup/nestjs__cli
 
 | Field | Value |
 |-------|-------|
-| Original | [@nestjs/cli](https://www.npmjs.com/package/@nestjs/cli) @ 11.0.24 |
-| Processed | 2026-08-20 |
+| Original | [@nestjs/cli](https://www.npmjs.com/package/@nestjs/cli) @ 12.0.0 |
+| Processed | 2026-08-27 |
 | Smoke test | failed |
-| Deps updated | 12 |
+| Deps updated | 4 |
 
 ## Dependency Changes
 
 | Dependency | From | To |
 |------------|------|-----|
-| @angular-devkit/core | 19.2.27 | ^22.1.5 |
-| @angular-devkit/schematics | 19.2.27 | ^22.1.5 |
-| @angular-devkit/schematics-cli | 19.2.27 | ^22.1.5 |
-| @inquirer/prompts | 7.10.1 | ^8.6.0 |
-| @nestjs/schematics | ^11.0.1 | ^11.1.0 |
-| ansis | 4.2.0 | ^4.3.1 |
-| chokidar | 4.0.3 | ^5.0.0 |
-| commander | 4.1.1 | ^15.0.0 |
-| node-emoji | 1.11.0 | ^2.2.0 |
-| ora | 5.4.1 | ^9.4.1 |
-| typescript | 5.9.3 | ^7.0.2 |
-| webpack | 5.106.2 | ^5.109.2 |
+| @angular-devkit/core | 22.1.5 | ^22.1.6 |
+| @angular-devkit/schematics | 22.1.5 | ^22.1.6 |
+| @angular-devkit/schematics-cli | 22.1.5 | ^22.1.6 |
+| typescript | ~6.0.2 | ^7.0.2 |
 
 ---
 

package/actions/abstract.action.d.ts

@@ -1,4 +1,3 @@
-import { Input } from '../commands';
 export declare abstract class AbstractAction {
-    abstract handle(inputs?: Input[], options?: Input[], extraFlags?: string[]): Promise<void>;
+    abstract handle(context?: any): Promise<void>;
 }

package/actions/abstract.action.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractAction = void 0;
-class AbstractAction {
+export class AbstractAction {
 }
-exports.AbstractAction = AbstractAction;

package/actions/add.action.d.ts

@@ -1,11 +1,10 @@
-import { Input } from '../commands';
-import { AbstractAction } from './abstract.action';
+import { AddCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class AddAction extends AbstractAction {
-    handle(inputs: Input[], options: Input[], extraFlags: string[]): Promise<void>;
+    handle(context: AddCommandContext): Promise<void>;
     private getSourceRoot;
     private installPackage;
     private addLibrary;
-    private getLibraryName;
     private getPackageName;
     private getCollectionName;
     private getTagName;

package/actions/add.action.js

@@ -1,42 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddAction = void 0;
-const ansis_1 = require("ansis");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const package_managers_1 = require("../lib/package-managers");
-const schematics_1 = require("../lib/schematics");
-const ui_1 = require("../lib/ui");
-const load_configuration_1 = require("../lib/utils/load-configuration");
-const project_utils_1 = require("../lib/utils/project-utils");
-const abstract_action_1 = require("./abstract.action");
+import { red } from 'ansis';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { PackageManagerFactory, } from '../lib/package-managers/index.js';
+import { CollectionFactory, SchematicOption, } from '../lib/schematics/index.js';
+import { MESSAGES } from '../lib/ui/index.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { askForProjectName, moveDefaultProjectToStart, shouldAskForProject, } from '../lib/utils/project-utils.js';
+import { AbstractAction } from './abstract.action.js';
 const schematicName = 'nest-add';
-class AddAction extends abstract_action_1.AbstractAction {
-    async handle(inputs, options, extraFlags) {
-        const libraryName = this.getLibraryName(inputs);
+export class AddAction extends AbstractAction {
+    async handle(context) {
+        const libraryName = context.library;
         const packageName = this.getPackageName(libraryName);
         const collectionName = this.getCollectionName(libraryName, packageName);
         const tagName = this.getTagName(packageName);
-        const skipInstall = (0, project_utils_1.hasValidOptionFlag)('skip-install', options);
-        const packageInstallSuccess = skipInstall || (await this.installPackage(collectionName, tagName));
+        const packageInstallSuccess = context.skipInstall ||
+            (await this.installPackage(collectionName, tagName));
         if (packageInstallSuccess) {
-            const sourceRootOption = await this.getSourceRoot(inputs.concat(options));
-            options.push(sourceRootOption);
-            await this.addLibrary(collectionName, options, extraFlags);
+            const sourceRoot = await this.getSourceRoot(context.project);
+            await this.addLibrary(collectionName, sourceRoot, context.extraFlags);
         }
         else {
-            console.error((0, ansis_1.red)(ui_1.MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName)));
-            throw new Error(ui_1.MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName));
+            console.error(red(MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName)));
+            throw new Error(MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName));
         }
     }
-    async getSourceRoot(inputs) {
-        const configuration = await (0, load_configuration_1.loadConfiguration)();
+    async getSourceRoot(project) {
+        const configuration = await loadConfiguration();
         const configurationProjects = configuration.projects;
-        const appName = inputs.find((option) => option.name === 'project')
-            .value;
-        let sourceRoot = appName
-            ? (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName)
+        let sourceRoot = project
+            ? getValueOrDefault(configuration, 'sourceRoot', project)
             : configuration.sourceRoot;
-        const shouldAsk = (0, project_utils_1.shouldAskForProject)(schematicName, configurationProjects, appName);
+        const shouldAsk = shouldAskForProject(schematicName, configurationProjects, project ?? '');
         if (shouldAsk) {
             const defaultLabel = ' [ Default ]';
             let defaultProjectName = configuration.sourceRoot + defaultLabel;
@@ -47,52 +41,45 @@ class AddAction extends abstract_action_1.AbstractAction {
                     break;
                 }
             }
-            const projects = (0, project_utils_1.moveDefaultProjectToStart)(configuration, defaultProjectName, defaultLabel);
-            const selectedProject = (await (0, project_utils_1.askForProjectName)(ui_1.MESSAGES.LIBRARY_PROJECT_SELECTION_QUESTION, projects));
-            const project = selectedProject.replace(defaultLabel, '');
-            if (project !== configuration.sourceRoot) {
-                sourceRoot = configurationProjects[project].sourceRoot;
+            const projects = moveDefaultProjectToStart(configuration, defaultProjectName, defaultLabel);
+            const selectedProject = (await askForProjectName(MESSAGES.LIBRARY_PROJECT_SELECTION_QUESTION, projects));
+            const projectName = selectedProject.replace(defaultLabel, '');
+            if (projectName !== configuration.sourceRoot) {
+                sourceRoot = configurationProjects[projectName].sourceRoot;
             }
         }
-        return { name: 'sourceRoot', value: sourceRoot };
+        return sourceRoot;
     }
     async installPackage(collectionName, tagName) {
-        const manager = await package_managers_1.PackageManagerFactory.find();
+        const manager = await PackageManagerFactory.find();
         tagName = tagName || 'latest';
         let installResult = false;
         try {
             installResult = await manager.addProduction([collectionName], tagName);
         }
         catch (error) {
-            if (error && error.message) {
-                console.error((0, ansis_1.red)(error.message));
+            if (error instanceof Error) {
+                console.error(red(error.message));
             }
         }
         return installResult;
     }
-    async addLibrary(collectionName, options, extraFlags) {
-        console.info(ui_1.MESSAGES.LIBRARY_INSTALLATION_STARTS);
+    async addLibrary(collectionName, sourceRoot, extraFlags) {
+        console.info(MESSAGES.LIBRARY_INSTALLATION_STARTS);
         const schematicOptions = [];
-        schematicOptions.push(new schematics_1.SchematicOption('sourceRoot', options.find((option) => option.name === 'sourceRoot').value));
+        schematicOptions.push(new SchematicOption('sourceRoot', sourceRoot));
         const extraFlagsString = extraFlags ? extraFlags.join(' ') : undefined;
         try {
-            const collection = schematics_1.CollectionFactory.create(collectionName);
+            const collection = CollectionFactory.create(collectionName);
             await collection.execute(schematicName, schematicOptions, extraFlagsString);
         }
         catch (error) {
-            if (error && error.message) {
-                console.error((0, ansis_1.red)(error.message));
-                return Promise.reject();
+            if (error instanceof Error) {
+                console.error(red(error.message));
             }
+            throw error;
         }
     }
-    getLibraryName(inputs) {
-        const libraryInput = inputs.find((input) => input.name === 'library');
-        if (!libraryInput) {
-            throw new Error('No library found in command input');
-        }
-        return libraryInput.value;
-    }
     getPackageName(library) {
         return library.startsWith('@')
             ? library.split('/', 2).join('/')
@@ -105,9 +92,13 @@ class AddAction extends abstract_action_1.AbstractAction {
             library.slice(packageName.length));
     }
     getTagName(packageName) {
-        return packageName.startsWith('@')
+        // For scoped packages like "@scope/pkg@1.0.0", split('@', 3) yields
+        // ["", "scope/pkg", "1.0.0"]. For "@scope/pkg" with no version,
+        // the tag slot is undefined. Fall back to an empty string so the
+        // return type stays string and installPackage can substitute "latest".
+        const tag = packageName.startsWith('@')
             ? packageName.split('@', 3)[2]
             : packageName.split('@', 2)[1];
+        return tag ?? '';
     }
 }
-exports.AddAction = AddAction;

package/actions/build.action.d.ts

@@ -1,22 +1,29 @@
-import { Input } from '../commands';
-import { AssetsManager } from '../lib/compiler/assets-manager';
-import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider';
-import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader';
-import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader';
-import { ConfigurationLoader } from '../lib/configuration';
-import { FileSystemReader } from '../lib/readers';
-import { AbstractAction } from './abstract.action';
+import { AssetsManager } from '../lib/compiler/assets-manager.js';
+import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider.js';
+import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader.js';
+import { ConfigurationLoader } from '../lib/configuration/index.js';
+import { FileSystemReader } from '../lib/readers/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class BuildAction extends AbstractAction {
     protected readonly pluginsLoader: PluginsLoader;
     protected readonly tsLoader: TypeScriptBinaryLoader;
     protected readonly tsConfigProvider: TsConfigProvider;
     protected readonly fileSystemReader: FileSystemReader;
     protected readonly loader: ConfigurationLoader;
-    protected readonly assetsManager: AssetsManager;
-    handle(commandInputs: Input[], commandOptions: Input[]): Promise<void>;
-    runBuild(commandInputs: Input[], commandOptions: Input[], watchMode: boolean, watchAssetsMode: boolean, isDebugEnabled?: boolean, onSuccess?: () => void): Promise<void>;
+    /**
+     * Each app build owns its assets manager: `closeWatchers()` closes every
+     * watcher it holds, so a manager shared across a `--parallel` run would let
+     * the first app to finish tear down the watchers of apps still building.
+     */
+    protected createAssetsManager(): AssetsManager;
+    handle(context: any): Promise<void>;
+    runBuild(apps: (string | undefined)[], options: Record<string, any>, watchMode: boolean, watchAssetsMode: boolean, isDebugEnabled?: boolean, onSuccess?: () => void): Promise<void>;
     private runSwc;
     private runWebpack;
     private runTsc;
     private getWebpackConfigFactoryByPath;
+    private runRspack;
+    private getRspackConfigFactoryByPath;
+    private warnOnIgnoredLibraryAssets;
 }

package/actions/build.action.js

@@ -1,145 +1,238 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildAction = void 0;
-const ansis_1 = require("ansis");
-const path_1 = require("path");
-const assets_manager_1 = require("../lib/compiler/assets-manager");
-const delete_out_dir_1 = require("../lib/compiler/helpers/delete-out-dir");
-const get_builder_1 = require("../lib/compiler/helpers/get-builder");
-const get_tsc_config_path_1 = require("../lib/compiler/helpers/get-tsc-config.path");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const get_webpack_config_path_1 = require("../lib/compiler/helpers/get-webpack-config-path");
-const tsconfig_provider_1 = require("../lib/compiler/helpers/tsconfig-provider");
-const plugins_loader_1 = require("../lib/compiler/plugins/plugins-loader");
-const typescript_loader_1 = require("../lib/compiler/typescript-loader");
-const configuration_1 = require("../lib/configuration");
-const defaults_1 = require("../lib/configuration/defaults");
-const readers_1 = require("../lib/readers");
-const ui_1 = require("../lib/ui");
-const is_module_available_1 = require("../lib/utils/is-module-available");
-const abstract_action_1 = require("./abstract.action");
-class BuildAction extends abstract_action_1.AbstractAction {
-    constructor() {
-        super(...arguments);
-        this.pluginsLoader = new plugins_loader_1.PluginsLoader();
-        this.tsLoader = new typescript_loader_1.TypeScriptBinaryLoader();
-        this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.tsLoader);
-        this.fileSystemReader = new readers_1.FileSystemReader(process.cwd());
-        this.loader = new configuration_1.NestConfigurationLoader(this.fileSystemReader);
-        this.assetsManager = new assets_manager_1.AssetsManager();
+import { createRequire } from 'module';
+import { red } from 'ansis';
+import { join } from 'path';
+import { AssetsManager } from '../lib/compiler/assets-manager.js';
+import { deleteOutDirIfEnabled } from '../lib/compiler/helpers/delete-out-dir.js';
+import { getBuilder } from '../lib/compiler/helpers/get-builder.js';
+import { getEffectiveRootDir } from '../lib/compiler/helpers/get-effective-root-dir.js';
+import { getRspackConfigPath } from '../lib/compiler/helpers/get-rspack-config-path.js';
+import { getTscConfigPath } from '../lib/compiler/helpers/get-tsc-config.path.js';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { getWebpackConfigPath } from '../lib/compiler/helpers/get-webpack-config-path.js';
+import { TsConfigProvider, } from '../lib/compiler/helpers/tsconfig-provider.js';
+import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader.js';
+import { NestConfigurationLoader, } from '../lib/configuration/index.js';
+import { defaultOutDir, defaultRspackConfigFilename, defaultWebpackConfigFilename, } from '../lib/configuration/defaults.js';
+import { FileSystemReader } from '../lib/readers/index.js';
+import { ERROR_PREFIX, INFO_PREFIX } from '../lib/ui/index.js';
+import { isModuleAvailable } from '../lib/utils/is-module-available.js';
+import { AbstractAction } from './abstract.action.js';
+const require = createRequire(import.meta.url);
+export class BuildAction extends AbstractAction {
+    pluginsLoader = new PluginsLoader();
+    tsLoader = new TypeScriptBinaryLoader();
+    tsConfigProvider = new TsConfigProvider(this.tsLoader);
+    fileSystemReader = new FileSystemReader(process.cwd());
+    loader = new NestConfigurationLoader(this.fileSystemReader);
+    /**
+     * Each app build owns its assets manager: `closeWatchers()` closes every
+     * watcher it holds, so a manager shared across a `--parallel` run would let
+     * the first app to finish tear down the watchers of apps still building.
+     */
+    createAssetsManager() {
+        return new AssetsManager();
     }
-    async handle(commandInputs, commandOptions) {
+    async handle(context) {
+        const { apps, watch, watchAssets } = context;
         try {
-            const watchModeOption = commandOptions.find((option) => option.name === 'watch');
-            const watchMode = !!(watchModeOption && watchModeOption.value);
-            const watchAssetsModeOption = commandOptions.find((option) => option.name === 'watchAssets');
-            const watchAssetsMode = !!(watchAssetsModeOption && watchAssetsModeOption.value);
-            await this.runBuild(commandInputs, commandOptions, watchMode, watchAssetsMode);
+            await this.runBuild(apps, context, watch, watchAssets);
         }
         catch (err) {
             if (err instanceof Error) {
-                console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+                console.error(`\n${ERROR_PREFIX} ${err.message}\n`);
             }
             else {
-                console.error(`\n${(0, ansis_1.red)(err)}\n`);
+                console.error(`\n${red(err)}\n`);
             }
             process.exit(1);
         }
     }
-    async runBuild(commandInputs, commandOptions, watchMode, watchAssetsMode, isDebugEnabled = false, onSuccess) {
-        const configFileName = commandOptions.find((option) => option.name === 'config').value;
+    async runBuild(apps, options, watchMode, watchAssetsMode, isDebugEnabled = false, onSuccess) {
+        const configFileName = options.config;
         const configuration = await this.loader.load(configFileName);
-        const buildAll = commandOptions.find((opt) => opt.name === 'all')?.value;
         let appNames;
-        if (buildAll) {
-            // If the "all" flag is set, we need to build all projects in a monorepo.
+        if (options.all) {
             appNames = [];
             if (configuration.projects) {
                 appNames.push(...Object.keys(configuration.projects));
             }
         }
         else {
-            appNames = commandInputs
-                .filter((input) => input.name === 'app')
-                .map((input) => input.value);
+            appNames = apps;
         }
         if (appNames.length === 0) {
-            // If there are no projects, use "undefined" to build the default project.
             appNames.push(undefined);
         }
-        for (const appName of appNames) {
-            const pathToTsconfig = (0, get_tsc_config_path_1.getTscConfigPath)(configuration, commandOptions, appName);
-            const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
-            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
-            const isWebpackEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpack', appName, 'webpack', commandOptions);
+        const appBuildContexts = appNames.map((appName) => {
+            const pathToTsconfig = getTscConfigPath(configuration, options, appName);
+            const { exclude, options: tsOptions, fileNames: tsFileNames, } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
+            return {
+                appName,
+                pathToTsconfig,
+                tsOptions,
+                exclude,
+                outDir: tsOptions.outDir || defaultOutDir,
+                tsRootDir: getEffectiveRootDir(tsOptions.rootDir, tsFileNames),
+            };
+        });
+        // Every output directory is cleaned before any app starts emitting.
+        // Cleaning inside the per-app build deletes output another app already
+        // wrote whenever projects share an outDir (the default monorepo layout):
+        // a race under `--parallel`, and deterministic clobbering under `--all`.
+        for (const { appName, outDir, tsOptions } of appBuildContexts) {
+            await deleteOutDirIfEnabled(configuration, appName, outDir, tsOptions);
+        }
+        this.warnOnIgnoredLibraryAssets(configuration, appNames);
+        const buildApp = async ({ appName, pathToTsconfig, tsOptions, exclude, outDir, tsRootDir, }) => {
+            const assetsManager = this.createAssetsManager();
+            const isWebpackEnabled = getValueOrDefault(configuration, 'compilerOptions.webpack', appName, 'webpack', options);
             const builder = isWebpackEnabled
                 ? { type: 'webpack' }
-                : (0, get_builder_1.getBuilder)(configuration, commandOptions, appName);
-            await (0, delete_out_dir_1.deleteOutDirIfEnabled)(configuration, appName, outDir, tsOptions);
-            this.assetsManager.copyAssets(configuration, appName, outDir, watchAssetsMode);
-            const typeCheck = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', commandOptions);
+                : getBuilder(configuration, options, appName);
+            assetsManager.copyAssets(configuration, appName, outDir, watchAssetsMode, onSuccess, tsRootDir);
+            const typeCheck = getValueOrDefault(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options);
             if (typeCheck && builder.type !== 'swc') {
-                console.warn(ui_1.INFO_PREFIX +
+                console.warn(INFO_PREFIX +
                     ` "typeCheck" will not have any effect when "builder" is not "swc".`);
             }
+            const emitDeclarations = getValueOrDefault(configuration, 'compilerOptions.emitDeclarations', appName, 'emitDeclarations', options);
+            if (emitDeclarations && builder.type !== 'swc') {
+                console.warn(INFO_PREFIX +
+                    ` "emitDeclarations" will not have any effect when "builder" is not "swc".`);
+            }
             switch (builder.type) {
                 case 'tsc':
-                    await this.runTsc(watchMode, commandOptions, configuration, pathToTsconfig, appName, onSuccess);
+                    await this.runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess, assetsManager);
                     break;
                 case 'webpack':
-                    await this.runWebpack(configuration, appName, commandOptions, pathToTsconfig, isDebugEnabled, watchMode, onSuccess);
+                    await this.runWebpack(configuration, appName, options, pathToTsconfig, isDebugEnabled, watchMode, onSuccess, assetsManager);
+                    break;
+                case 'rspack':
+                    await this.runRspack(configuration, appName, options, pathToTsconfig, tsOptions, isDebugEnabled, watchMode, onSuccess, assetsManager);
                     break;
                 case 'swc':
-                    await this.runSwc(configuration, appName, pathToTsconfig, watchMode, commandOptions, tsOptions, onSuccess);
+                    await this.runSwc(configuration, appName, pathToTsconfig, watchMode, options, tsOptions, exclude, emitDeclarations, onSuccess, assetsManager);
                     break;
             }
+        };
+        const parallel = options.parallel;
+        if (parallel && appBuildContexts.length > 1) {
+            // Coerce to a positive integer; fall back to unlimited for any
+            // non-positive or non-finite value to guard against an infinite loop
+            // when `i += concurrency` would never advance.
+            const requested = typeof parallel === 'number' ? parallel : appBuildContexts.length;
+            const concurrency = Number.isFinite(requested) && requested >= 1
+                ? Math.floor(requested)
+                : appBuildContexts.length;
+            for (let i = 0; i < appBuildContexts.length; i += concurrency) {
+                const chunk = appBuildContexts.slice(i, i + concurrency);
+                await Promise.all(chunk.map((context) => buildApp(context)));
+            }
+        }
+        else {
+            for (const context of appBuildContexts) {
+                await buildApp(context);
+            }
         }
     }
-    async runSwc(configuration, appName, pathToTsconfig, watchMode, options, tsOptions, onSuccess) {
-        const { SwcCompiler } = await Promise.resolve().then(() => require('../lib/compiler/swc/swc-compiler'));
+    async runSwc(configuration, appName, pathToTsconfig, watchMode, options, tsOptions, tsConfigExclude, emitDeclarations, onSuccess, assetsManager) {
+        const { SwcCompiler } = await import('../lib/compiler/swc/swc-compiler.js');
         const swc = new SwcCompiler(this.pluginsLoader);
+        const isSilent = !!options.silent;
         await swc.run(configuration, pathToTsconfig, appName, {
             watch: watchMode,
-            typeCheck: (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options),
+            typeCheck: getValueOrDefault(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options),
+            emitDeclarations,
             tsOptions,
-            assetsManager: this.assetsManager,
+            tsConfigExclude,
+            assetsManager,
+            silent: isSilent,
         }, onSuccess);
     }
-    async runWebpack(configuration, appName, commandOptions, pathToTsconfig, debug, watchMode, onSuccess) {
-        const { WebpackCompiler } = await Promise.resolve().then(() => require('../lib/compiler/webpack-compiler'));
+    async runWebpack(configuration, appName, options, pathToTsconfig, debug, watchMode, onSuccess, assetsManager) {
+        const { WebpackCompiler } = await import('../lib/compiler/webpack-compiler.js');
         const webpackCompiler = new WebpackCompiler(this.pluginsLoader);
-        const webpackPath = (0, get_webpack_config_path_1.getWebpackConfigPath)(configuration, commandOptions, appName) ??
-            defaults_1.defaultWebpackConfigFilename;
-        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, defaults_1.defaultWebpackConfigFilename);
+        const webpackPath = getWebpackConfigPath(configuration, options, appName) ??
+            defaultWebpackConfigFilename;
+        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, defaultWebpackConfigFilename);
         return webpackCompiler.run(configuration, pathToTsconfig, appName, {
-            inputs: commandOptions,
+            options,
             webpackConfigFactoryOrConfig,
             debug,
             watchMode,
-            assetsManager: this.assetsManager,
+            assetsManager,
         }, onSuccess);
     }
-    async runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess) {
+    async runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess, assetsManager) {
         if (watchMode) {
-            const { WatchCompiler } = await Promise.resolve().then(() => require('../lib/compiler/watch-compiler'));
+            const { WatchCompiler } = await import('../lib/compiler/watch-compiler.js');
             const watchCompiler = new WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
-            const isPreserveWatchOutputEnabled = options.find((option) => option.name === 'preserveWatchOutput' && option.value === true)?.value;
+            const isPreserveWatchOutputEnabled = !!options.preserveWatchOutput;
             watchCompiler.run(configuration, pathToTsconfig, appName, { preserveWatchOutput: isPreserveWatchOutputEnabled }, onSuccess);
         }
         else {
-            const { Compiler } = await Promise.resolve().then(() => require('../lib/compiler/compiler'));
+            const { Compiler } = await import('../lib/compiler/compiler.js');
             const compiler = new Compiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
             compiler.run(configuration, pathToTsconfig, appName, undefined, onSuccess);
-            await this.assetsManager.closeWatchers();
+            await assetsManager.closeWatchers();
         }
     }
     getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
-        const pathToWebpackFile = (0, path_1.join)(process.cwd(), webpackPath);
-        const isWebpackFileAvailable = (0, is_module_available_1.isModuleAvailable)(pathToWebpackFile);
+        const pathToWebpackFile = join(process.cwd(), webpackPath);
+        const isWebpackFileAvailable = isModuleAvailable(pathToWebpackFile);
         if (!isWebpackFileAvailable && webpackPath === defaultPath) {
-            return ({}) => ({});
+            return (_config) => ({});
         }
         return require(pathToWebpackFile);
     }
+    async runRspack(configuration, appName, options, pathToTsconfig, tsOptions, debug, watchMode, onSuccess, assetsManager) {
+        const { RspackCompiler } = await import('../lib/compiler/rspack-compiler.js');
+        const rspackCompiler = new RspackCompiler(this.pluginsLoader);
+        const rspackPath = getRspackConfigPath(configuration, options, appName) ??
+            defaultRspackConfigFilename;
+        const rspackConfigFactoryOrConfig = this.getRspackConfigFactoryByPath(rspackPath, defaultRspackConfigFilename);
+        return rspackCompiler.run(configuration, pathToTsconfig, appName, {
+            options,
+            rspackConfigFactoryOrConfig,
+            debug,
+            watchMode,
+            tsOptions,
+            assetsManager,
+        }, onSuccess);
+    }
+    getRspackConfigFactoryByPath(rspackPath, defaultPath) {
+        const pathToRspackFile = join(process.cwd(), rspackPath);
+        const isRspackFileAvailable = isModuleAvailable(pathToRspackFile);
+        if (!isRspackFileAvailable && rspackPath === defaultPath) {
+            return (_config) => ({});
+        }
+        return require(pathToRspackFile);
+    }
+    warnOnIgnoredLibraryAssets(configuration, appNames) {
+        if (!configuration.projects) {
+            return;
+        }
+        // A library whose assets any of the apps being built opts into via
+        // `includeLibraryAssets` *is* copied, so warning about it would be wrong.
+        const includedLibraries = new Set();
+        for (const appName of appNames) {
+            const included = getValueOrDefault(configuration, 'compilerOptions.includeLibraryAssets', appName) || [];
+            for (const libraryName of included) {
+                includedLibraries.add(libraryName);
+            }
+        }
+        for (const [projectName, project] of Object.entries(configuration.projects)) {
+            if (appNames.includes(projectName) ||
+                includedLibraries.has(projectName)) {
+                continue;
+            }
+            if (project.type === 'library' &&
+                project.compilerOptions?.assets?.length) {
+                console.warn(INFO_PREFIX +
+                    ` Assets configured for library "${projectName}" will not be copied during application build.` +
+                    ` Add it to "compilerOptions.includeLibraryAssets" or build the library separately.`);
+            }
+        }
+    }
 }
-exports.BuildAction = BuildAction;

package/actions/deploy.action.d.ts

@@ -0,0 +1,6 @@
+import { DeployCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
+export declare class DeployAction extends AbstractAction {
+    handle(context: DeployCommandContext): Promise<void>;
+    private installMau;
+}