@angular/cli 20.2.0 → 21.0.0-next.0

package/lib/config/schema.json

@@ -4377,6 +4377,10 @@
             "type": "string"
           },
           "description": "A list of global setup and configuration files that are included before the test files. The application's polyfills are always included before these files. The Angular Testbed is also initialized prior to the execution of these files."
+        },
+        "progress": {
+          "type": "boolean",
+          "description": "Log progress to the console while building. Defaults to the build target's progress value."
         }
       },
       "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "20.2.0",
+  "version": "21.0.0-next.0",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -25,13 +25,13 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.2002.0",
-    "@angular-devkit/core": "20.2.0",
-    "@angular-devkit/schematics": "20.2.0",
-    "@inquirer/prompts": "7.8.2",
+    "@angular-devkit/architect": "0.2100.0-next.0",
+    "@angular-devkit/core": "21.0.0-next.0",
+    "@angular-devkit/schematics": "21.0.0-next.0",
+    "@inquirer/prompts": "7.8.3",
     "@listr2/prompt-adapter-inquirer": "3.0.1",
     "@modelcontextprotocol/sdk": "1.17.3",
-    "@schematics/angular": "20.2.0",
+    "@schematics/angular": "21.0.0-next.0",
     "@yarnpkg/lockfile": "1.1.0",
     "algoliasearch": "5.35.0",
     "ini": "5.0.0",
@@ -47,17 +47,17 @@
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "20.2.0",
-      "@angular/build": "20.2.0",
-      "@angular/ssr": "20.2.0",
-      "@angular-devkit/architect": "0.2002.0",
-      "@angular-devkit/build-angular": "20.2.0",
-      "@angular-devkit/build-webpack": "0.2002.0",
-      "@angular-devkit/core": "20.2.0",
-      "@angular-devkit/schematics": "20.2.0"
+      "@angular/cli": "21.0.0-next.0",
+      "@angular/build": "21.0.0-next.0",
+      "@angular/ssr": "21.0.0-next.0",
+      "@angular-devkit/architect": "0.2100.0-next.0",
+      "@angular-devkit/build-angular": "21.0.0-next.0",
+      "@angular-devkit/build-webpack": "0.2100.0-next.0",
+      "@angular-devkit/core": "21.0.0-next.0",
+      "@angular-devkit/schematics": "21.0.0-next.0"
     }
   },
-  "packageManager": "pnpm@10.14.0",
+  "packageManager": "pnpm@10.15.0",
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
     "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",

package/src/commands/add/cli.d.ts

@@ -23,6 +23,11 @@ export default class AddCommandModule extends SchematicsCommandModule implements
     private rootRequire;
     builder(argv: Argv): Promise<Argv<AddCommandArgs>>;
     run(options: Options<AddCommandArgs> & OtherOptions): Promise<number | void>;
+    private determinePackageManagerTask;
+    private findCompatiblePackageVersionTask;
+    private loadPackageInfoTask;
+    private confirmInstallationTask;
+    private installPackageTask;
     private isProjectVersionValid;
     private getCollectionName;
     private isPackageInstalled;

package/src/commands/add/cli.js

@@ -116,10 +116,9 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         }
         return localYargs;
     }
-    // eslint-disable-next-line max-lines-per-function
     async run(options) {
-        const { logger, packageManager } = this.context;
-        const { verbose, registry, collection, skipConfirmation } = options;
+        const { logger } = this.context;
+        const { collection, skipConfirmation } = options;
         let packageIdentifier;
         try {
             packageIdentifier = (0, npm_package_arg_1.default)(collection);
@@ -147,163 +146,34 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         const tasks = new listr2_1.Listr([
             {
                 title: 'Determining Package Manager',
-                task(context, task) {
-                    context.usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
-                    task.output = `Using package manager: ${listr2_1.color.dim(packageManager.name)}`;
-                },
+                task: (context, task) => this.determinePackageManagerTask(context, task),
                 rendererOptions: { persistentOutput: true },
             },
             {
                 title: 'Searching for compatible package version',
                 enabled: packageIdentifier.type === 'range' && packageIdentifier.rawSpec === '*',
-                async task(context, task) {
-                    (0, node_assert_1.default)(context.packageIdentifier.name, 'Registry package identifiers should always have a name.');
-                    // only package name provided; search for viable version
-                    // plus special cases for packages that did not have peer deps setup
-                    let packageMetadata;
-                    try {
-                        packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(context.packageIdentifier.name, logger, {
-                            registry,
-                            usingYarn: context.usingYarn,
-                            verbose,
-                        });
-                    }
-                    catch (e) {
-                        (0, error_1.assertIsError)(e);
-                        throw new CommandError(`Unable to load package information from registry: ${e.message}`);
-                    }
-                    // Start with the version tagged as `latest` if it exists
-                    const latestManifest = packageMetadata.tags['latest'];
-                    if (latestManifest) {
-                        context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
-                    }
-                    // Adjust the version based on name and peer dependencies
-                    if (latestManifest?.peerDependencies &&
-                        Object.keys(latestManifest.peerDependencies).length === 0) {
-                        task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
-                    }
-                    else if (!latestManifest || (await context.hasMismatchedPeer(latestManifest))) {
-                        // 'latest' is invalid so search for most recent matching package
-                        // Allow prelease versions if the CLI itself is a prerelease
-                        const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
-                        const versionExclusions = packageVersionExclusions[packageMetadata.name];
-                        const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
-                            // Prerelease versions are not stable and should not be considered by default
-                            if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
-                                return false;
-                            }
-                            // Deprecated versions should not be used or considered
-                            if (value.deprecated) {
-                                return false;
-                            }
-                            // Excluded package versions should not be considered
-                            if (versionExclusions &&
-                                (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
-                                return false;
-                            }
-                            return true;
-                        });
-                        // Sort in reverse SemVer order so that the newest compatible version is chosen
-                        versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
-                        let found = false;
-                        for (const versionManifest of versionManifests) {
-                            const mismatch = await context.hasMismatchedPeer(versionManifest);
-                            if (mismatch) {
-                                continue;
-                            }
-                            context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
-                            found = true;
-                            break;
-                        }
-                        if (!found) {
-                            task.output = "Unable to find compatible package. Using 'latest' tag.";
-                        }
-                        else {
-                            task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
-                        }
-                    }
-                    else {
-                        task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
-                    }
-                },
+                task: (context, task) => this.findCompatiblePackageVersionTask(context, task, options),
                 rendererOptions: { persistentOutput: true },
             },
             {
                 title: 'Loading package information from registry',
-                async task(context, task) {
-                    let manifest;
-                    try {
-                        manifest = await (0, package_metadata_1.fetchPackageManifest)(context.packageIdentifier.toString(), logger, {
-                            registry,
-                            verbose,
-                            usingYarn: context.usingYarn,
-                        });
-                    }
-                    catch (e) {
-                        (0, error_1.assertIsError)(e);
-                        throw new CommandError(`Unable to fetch package information for '${context.packageIdentifier}': ${e.message}`);
-                    }
-                    context.savePackage = manifest['ng-add']?.save;
-                    context.collectionName = manifest.name;
-                    if (await context.hasMismatchedPeer(manifest)) {
-                        task.output = listr2_1.color.yellow(listr2_1.figures.warning +
-                            ' Package has unmet peer dependencies. Adding the package may not succeed.');
-                    }
-                },
+                task: (context, task) => this.loadPackageInfoTask(context, task, options),
                 rendererOptions: { persistentOutput: true },
             },
             {
                 title: 'Confirming installation',
                 enabled: !skipConfirmation,
-                async task(context, task) {
-                    if (!(0, tty_1.isTTY)()) {
-                        task.output =
-                            `'--skip-confirmation' can be used to bypass installation confirmation. ` +
-                                `Ensure package name is correct prior to '--skip-confirmation' option usage.`;
-                        throw new CommandError('No terminal detected');
-                    }
-                    const { ListrInquirerPromptAdapter } = await Promise.resolve().then(() => __importStar(require('@listr2/prompt-adapter-inquirer')));
-                    const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
-                    const shouldProceed = await task.prompt(ListrInquirerPromptAdapter).run(confirm, {
-                        message: `The package ${listr2_1.color.blue(context.packageIdentifier.toString())} will be installed and executed.\n` +
-                            'Would you like to proceed?',
-                        default: true,
-                        theme: { prefix: '' },
-                    });
-                    if (!shouldProceed) {
-                        throw new CommandError('Command aborted');
-                    }
-                },
+                task: (context, task) => this.confirmInstallationTask(context, task),
                 rendererOptions: { persistentOutput: true },
             },
             {
-                async task(context, task) {
-                    // Only show if installation will actually occur
-                    task.title = 'Installing package';
-                    if (context.savePackage === false) {
-                        task.title += ' in temporary location';
-                        // Temporary packages are located in a different directory
-                        // Hence we need to resolve them using the temp path
-                        const { success, tempNodeModules } = await packageManager.installTemp(context.packageIdentifier.toString(), registry ? [`--registry="${registry}"`] : undefined);
-                        const tempRequire = (0, node_module_1.createRequire)(tempNodeModules + '/');
-                        (0, node_assert_1.default)(context.collectionName, 'Collection name should always be available');
-                        const resolvedCollectionPath = tempRequire.resolve((0, node_path_1.join)(context.collectionName, 'package.json'));
-                        if (!success) {
-                            throw new CommandError('Unable to install package');
-                        }
-                        context.collectionName = (0, node_path_1.dirname)(resolvedCollectionPath);
-                    }
-                    else {
-                        const success = await packageManager.install(context.packageIdentifier.toString(), context.savePackage, registry ? [`--registry="${registry}"`] : undefined, undefined);
-                        if (!success) {
-                            throw new CommandError('Unable to install package');
-                        }
-                    }
-                },
+                task: (context, task) => this.installPackageTask(context, task, options),
                 rendererOptions: { bottomBar: Infinity },
             },
             // TODO: Rework schematic execution as a task and insert here
-        ]);
+        ], {
+        /* options */
+        });
         try {
             const result = await tasks.run(taskContext);
             (0, node_assert_1.default)(result.collectionName, 'Collection name should always be available');
@@ -311,11 +181,155 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         }
         catch (e) {
             if (e instanceof CommandError) {
+                logger.error(e.message);
                 return 1;
             }
             throw e;
         }
     }
+    determinePackageManagerTask(context, task) {
+        const { packageManager } = this.context;
+        context.usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
+        task.output = `Using package manager: ${listr2_1.color.dim(packageManager.name)}`;
+    }
+    async findCompatiblePackageVersionTask(context, task, options) {
+        const { logger } = this.context;
+        const { verbose, registry } = options;
+        (0, node_assert_1.default)(context.packageIdentifier.name, 'Registry package identifiers should always have a name.');
+        // only package name provided; search for viable version
+        // plus special cases for packages that did not have peer deps setup
+        let packageMetadata;
+        try {
+            packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(context.packageIdentifier.name, logger, {
+                registry,
+                usingYarn: context.usingYarn,
+                verbose,
+            });
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            throw new CommandError(`Unable to load package information from registry: ${e.message}`);
+        }
+        // Start with the version tagged as `latest` if it exists
+        const latestManifest = packageMetadata.tags['latest'];
+        if (latestManifest) {
+            context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+        }
+        // Adjust the version based on name and peer dependencies
+        if (latestManifest?.peerDependencies &&
+            Object.keys(latestManifest.peerDependencies).length === 0) {
+            task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
+        }
+        else if (!latestManifest || (await context.hasMismatchedPeer(latestManifest))) {
+            // 'latest' is invalid so search for most recent matching package
+            // Allow prelease versions if the CLI itself is a prerelease
+            const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
+            const versionExclusions = packageVersionExclusions[packageMetadata.name];
+            const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+                // Prerelease versions are not stable and should not be considered by default
+                if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
+                    return false;
+                }
+                // Deprecated versions should not be used or considered
+                if (value.deprecated) {
+                    return false;
+                }
+                // Excluded package versions should not be considered
+                if (versionExclusions &&
+                    (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
+                    return false;
+                }
+                return true;
+            });
+            // Sort in reverse SemVer order so that the newest compatible version is chosen
+            versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
+            let found = false;
+            for (const versionManifest of versionManifests) {
+                const mismatch = await context.hasMismatchedPeer(versionManifest);
+                if (mismatch) {
+                    continue;
+                }
+                context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+                found = true;
+                break;
+            }
+            if (!found) {
+                task.output = "Unable to find compatible package. Using 'latest' tag.";
+            }
+            else {
+                task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+            }
+        }
+        else {
+            task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+        }
+    }
+    async loadPackageInfoTask(context, task, options) {
+        const { logger } = this.context;
+        const { verbose, registry } = options;
+        let manifest;
+        try {
+            manifest = await (0, package_metadata_1.fetchPackageManifest)(context.packageIdentifier.toString(), logger, {
+                registry,
+                verbose,
+                usingYarn: context.usingYarn,
+            });
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            throw new CommandError(`Unable to fetch package information for '${context.packageIdentifier}': ${e.message}`);
+        }
+        context.savePackage = manifest['ng-add']?.save;
+        context.collectionName = manifest.name;
+        if (await context.hasMismatchedPeer(manifest)) {
+            task.output = listr2_1.color.yellow(listr2_1.figures.warning +
+                ' Package has unmet peer dependencies. Adding the package may not succeed.');
+        }
+    }
+    async confirmInstallationTask(context, task) {
+        if (!(0, tty_1.isTTY)()) {
+            task.output =
+                `'--skip-confirmation' can be used to bypass installation confirmation. ` +
+                    `Ensure package name is correct prior to '--skip-confirmation' option usage.`;
+            throw new CommandError('No terminal detected');
+        }
+        const { ListrInquirerPromptAdapter } = await Promise.resolve().then(() => __importStar(require('@listr2/prompt-adapter-inquirer')));
+        const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+        const shouldProceed = await task.prompt(ListrInquirerPromptAdapter).run(confirm, {
+            message: `The package ${listr2_1.color.blue(context.packageIdentifier.toString())} will be installed and executed.\n` +
+                'Would you like to proceed?',
+            default: true,
+            theme: { prefix: '' },
+        });
+        if (!shouldProceed) {
+            throw new CommandError('Command aborted');
+        }
+    }
+    async installPackageTask(context, task, options) {
+        const { packageManager } = this.context;
+        const { registry } = options;
+        // Only show if installation will actually occur
+        task.title = 'Installing package';
+        if (context.savePackage === false) {
+            task.title += ' in temporary location';
+            // Temporary packages are located in a different directory
+            // Hence we need to resolve them using the temp path
+            const { success, tempNodeModules } = await packageManager.installTemp(context.packageIdentifier.toString(), registry ? [`--registry="${registry}"`] : undefined);
+            const tempRequire = (0, node_module_1.createRequire)(tempNodeModules + '/');
+            (0, node_assert_1.default)(context.collectionName, 'Collection name should always be available');
+            const resolvedCollectionPath = tempRequire.resolve((0, node_path_1.join)(context.collectionName, 'package.json'));
+            if (!success) {
+                throw new CommandError('Unable to install package');
+            }
+            context.collectionName = (0, node_path_1.dirname)(resolvedCollectionPath);
+        }
+        else {
+            const success = await packageManager.install(context.packageIdentifier.toString(), context.savePackage, registry ? [`--registry="${registry}"`] : undefined, undefined);
+            if (!success) {
+                throw new CommandError('Unable to install package');
+            }
+        }
+    }
     async isProjectVersionValid(packageIdentifier) {
         if (!packageIdentifier.name) {
             return false;

package/src/utilities/version.js

@@ -22,4 +22,4 @@ class Version {
         this.patch = patch;
     }
 }
-exports.VERSION = new Version('20.2.0');
+exports.VERSION = new Version('21.0.0-next.0');