@angular/cli 20.2.1 → 21.0.0-next.1

package/lib/config/schema.json

@@ -51,7 +51,6 @@
           "type": "string",
           "enum": [
             "npm",
-            "cnpm",
             "yarn",
             "pnpm",
             "bun"
@@ -118,7 +117,6 @@
           "type": "string",
           "enum": [
             "npm",
-            "cnpm",
             "yarn",
             "pnpm",
             "bun"
@@ -1007,7 +1005,8 @@
             "css",
             "scss",
             "sass",
-            "less"
+            "less",
+            "tailwind"
           ]
         },
         "skipTests": {
@@ -1769,7 +1768,8 @@
             "css",
             "scss",
             "sass",
-            "less"
+            "less",
+            "tailwind"
           ]
         },
         "skipTests": {
@@ -1800,7 +1800,6 @@
             "npm",
             "yarn",
             "pnpm",
-            "cnpm",
             "bun"
           ]
         },
@@ -4377,6 +4376,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/lib/config/workspace-schema.d.ts

@@ -67,7 +67,6 @@ export declare enum Environment {
  */
 export declare enum PackageManager {
     Bun = "bun",
-    Cnpm = "cnpm",
     Npm = "npm",
     Pnpm = "pnpm",
     Yarn = "yarn"
@@ -196,7 +195,8 @@ export declare enum SchematicsAngularApplicationStyle {
     Css = "css",
     Less = "less",
     Sass = "sass",
-    Scss = "scss"
+    Scss = "scss",
+    Tailwind = "tailwind"
 }
 /**
  * Sets the view encapsulation mode for the application's components. This determines how

package/lib/config/workspace-schema.js

@@ -20,7 +20,6 @@ var Environment;
 var PackageManager;
 (function (PackageManager) {
     PackageManager["Bun"] = "bun";
-    PackageManager["Cnpm"] = "cnpm";
     PackageManager["Npm"] = "npm";
     PackageManager["Pnpm"] = "pnpm";
     PackageManager["Yarn"] = "yarn";
@@ -36,6 +35,7 @@ var SchematicsAngularApplicationStyle;
     SchematicsAngularApplicationStyle["Less"] = "less";
     SchematicsAngularApplicationStyle["Sass"] = "sass";
     SchematicsAngularApplicationStyle["Scss"] = "scss";
+    SchematicsAngularApplicationStyle["Tailwind"] = "tailwind";
 })(SchematicsAngularApplicationStyle || (exports.SchematicsAngularApplicationStyle = SchematicsAngularApplicationStyle = {}));
 /**
  * Sets the view encapsulation mode for the application's components. This determines how

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "20.2.1",
+  "version": "21.0.0-next.1",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -25,18 +25,18 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.2002.1",
-    "@angular-devkit/core": "20.2.1",
-    "@angular-devkit/schematics": "20.2.1",
-    "@inquirer/prompts": "7.8.2",
-    "@listr2/prompt-adapter-inquirer": "3.0.1",
-    "@modelcontextprotocol/sdk": "1.17.3",
-    "@schematics/angular": "20.2.1",
+    "@angular-devkit/architect": "0.2100.0-next.1",
+    "@angular-devkit/core": "21.0.0-next.1",
+    "@angular-devkit/schematics": "21.0.0-next.1",
+    "@inquirer/prompts": "7.8.4",
+    "@listr2/prompt-adapter-inquirer": "3.0.2",
+    "@modelcontextprotocol/sdk": "1.17.4",
+    "@schematics/angular": "21.0.0-next.1",
     "@yarnpkg/lockfile": "1.1.0",
-    "algoliasearch": "5.35.0",
+    "algoliasearch": "5.36.0",
     "ini": "5.0.0",
     "jsonc-parser": "3.3.1",
-    "listr2": "9.0.1",
+    "listr2": "9.0.2",
     "npm-package-arg": "13.0.0",
     "pacote": "21.0.0",
     "resolve": "1.22.10",
@@ -47,14 +47,14 @@
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "20.2.1",
-      "@angular/build": "20.2.1",
-      "@angular/ssr": "20.2.1",
-      "@angular-devkit/architect": "0.2002.1",
-      "@angular-devkit/build-angular": "20.2.1",
-      "@angular-devkit/build-webpack": "0.2002.1",
-      "@angular-devkit/core": "20.2.1",
-      "@angular-devkit/schematics": "20.2.1"
+      "@angular/cli": "21.0.0-next.1",
+      "@angular/build": "21.0.0-next.1",
+      "@angular/ssr": "21.0.0-next.1",
+      "@angular-devkit/architect": "0.2100.0-next.1",
+      "@angular-devkit/build-angular": "21.0.0-next.1",
+      "@angular-devkit/build-webpack": "0.2100.0-next.1",
+      "@angular-devkit/core": "21.0.0-next.1",
+      "@angular-devkit/schematics": "21.0.0-next.1"
     }
   },
   "packageManager": "pnpm@10.15.0",

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

@@ -15,6 +15,7 @@ interface AddCommandArgs extends SchematicsCommandArgs {
     'skip-confirmation'?: boolean;
 }
 export default class AddCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<AddCommandArgs> {
+    #private;
     command: string;
     describe: string;
     longDescriptionPath: string;
@@ -23,11 +24,16 @@ 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;
     private executeSchematic;
     private findProjectVersion;
-    private hasMismatchedPeer;
+    private getPeerDependencyConflicts;
 }
 export {};

package/src/commands/add/cli.js

@@ -69,6 +69,7 @@ const packageVersionExclusions = {
     // @angular/material@7.x versions have unbounded peer dependency ranges (>=7.0.0).
     '@angular/material': '7.x',
 };
+const DEFAULT_CONFLICT_DISPLAY_LIMIT = 5;
 class AddCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     command = 'add <collection>';
     describe = 'Adds support for an external library to your project.';
@@ -76,6 +77,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
     allowPrivateSchematics = true;
     schematicName = 'ng-add';
     rootRequire = (0, node_module_1.createRequire)(this.context.root + '/');
+    #projectVersionCache = new Map();
     async builder(argv) {
         const localYargs = (await super.builder(argv))
             .positional('collection', {
@@ -116,10 +118,10 @@ 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;
+        this.#projectVersionCache.clear();
+        const { logger } = this.context;
+        const { collection, skipConfirmation } = options;
         let packageIdentifier;
         try {
             packageIdentifier = (0, npm_package_arg_1.default)(collection);
@@ -142,180 +144,226 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         const taskContext = {
             packageIdentifier,
             executeSchematic: this.executeSchematic.bind(this),
-            hasMismatchedPeer: this.hasMismatchedPeer.bind(this),
+            getPeerDependencyConflicts: this.getPeerDependencyConflicts.bind(this),
+            dryRun: options.dryRun,
         };
         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');
-                    }
-                },
+                enabled: !skipConfirmation && !options.dryRun,
+                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');
-                        }
+                title: 'Installing package',
+                skip: (context) => {
+                    if (context.dryRun) {
+                        return `Skipping package installation. Would install package ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
                     }
+                    return false;
                 },
+                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');
+            if (options.dryRun) {
+                logger.info('The package schematic would be executed next.');
+                return;
+            }
             return this.executeSchematic({ ...options, collection: result.collectionName });
         }
         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}`);
+        }
+        const rejectionReasons = [];
+        // Start with the version tagged as `latest` if it exists
+        const latestManifest = packageMetadata.tags['latest'];
+        if (latestManifest) {
+            const latestConflicts = await this.getPeerDependencyConflicts(latestManifest);
+            if (latestConflicts) {
+                // 'latest' is invalid so search for most recent matching package
+                rejectionReasons.push(...latestConflicts);
+            }
+            else {
+                context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+                task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
+                return;
+            }
+        }
+        // Allow prelease versions if the CLI itself is a prerelease
+        const allowPrereleases = !!(0, semver_1.prerelease)(version_1.VERSION.full);
+        const versionManifests = this.#getPotentialVersionManifests(packageMetadata, allowPrereleases);
+        let found = false;
+        for (const versionManifest of versionManifests) {
+            // Already checked the 'latest' version
+            if (latestManifest?.version === versionManifest.version) {
+                continue;
+            }
+            const conflicts = await this.getPeerDependencyConflicts(versionManifest);
+            if (conflicts) {
+                if (options.verbose || rejectionReasons.length < DEFAULT_CONFLICT_DISPLAY_LIMIT) {
+                    rejectionReasons.push(...conflicts);
+                }
+                continue;
+            }
+            context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+            found = true;
+            break;
+        }
+        if (!found) {
+            let message = `Unable to find compatible package. Using 'latest' tag.`;
+            if (rejectionReasons.length > 0) {
+                message +=
+                    '\nThis is often because of incompatible peer dependencies.\n' +
+                        'These versions were rejected due to the following conflicts:\n' +
+                        rejectionReasons
+                            .slice(0, options.verbose ? undefined : DEFAULT_CONFLICT_DISPLAY_LIMIT)
+                            .map((r) => `  - ${r}`)
+                            .join('\n');
+            }
+            task.output = message;
+        }
+        else {
+            task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+        }
+    }
+    #getPotentialVersionManifests(packageMetadata, allowPrereleases) {
+        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
+        return versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
+    }
+    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 this.getPeerDependencyConflicts(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;
@@ -397,6 +445,10 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         }
     }
     async findProjectVersion(name) {
+        const cachedVersion = this.#projectVersionCache.get(name);
+        if (cachedVersion !== undefined) {
+            return cachedVersion;
+        }
         const { logger, root } = this.context;
         let installedPackage;
         try {
@@ -406,6 +458,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         if (installedPackage) {
             try {
                 const installed = await (0, package_metadata_1.fetchPackageManifest)((0, node_path_1.dirname)(installedPackage), logger);
+                this.#projectVersionCache.set(name, installed.version);
                 return installed.version;
             }
             catch { }
@@ -418,44 +471,50 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
         if (projectManifest) {
             const version = projectManifest.dependencies?.[name] || projectManifest.devDependencies?.[name];
             if (version) {
+                this.#projectVersionCache.set(name, version);
                 return version;
             }
         }
+        this.#projectVersionCache.set(name, null);
         return null;
     }
-    async hasMismatchedPeer(manifest) {
-        for (const peer in manifest.peerDependencies) {
+    async getPeerDependencyConflicts(manifest) {
+        if (!manifest.peerDependencies) {
+            return false;
+        }
+        const checks = Object.entries(manifest.peerDependencies).map(async ([peer, range]) => {
             let peerIdentifier;
             try {
-                peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
+                peerIdentifier = npm_package_arg_1.default.resolve(peer, range);
             }
             catch {
                 this.context.logger.warn(`Invalid peer dependency ${peer} found in package.`);
-                continue;
+                return null;
             }
-            if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
-                try {
-                    const version = await this.findProjectVersion(peer);
-                    if (!version) {
-                        continue;
-                    }
-                    const options = { includePrerelease: true };
-                    if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
-                        !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
-                        return true;
-                    }
+            if (peerIdentifier.type !== 'version' && peerIdentifier.type !== 'range') {
+                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                // Cannot accurately compare these as the tag/location may have changed since install.
+                return null;
+            }
+            try {
+                const version = await this.findProjectVersion(peer);
+                if (!version) {
+                    return null;
                 }
-                catch {
-                    // Not found or invalid so ignore
-                    continue;
+                const options = { includePrerelease: true };
+                if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
+                    !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
+                    return (`Package "${manifest.name}@${manifest.version}" has an incompatible peer dependency to "` +
+                        `${peer}@${peerIdentifier.rawSpec}" (requires "${version}" in project).`);
                 }
             }
-            else {
-                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
-                // Cannot accurately compare these as the tag/location may have changed since install
+            catch {
+                // Not found or invalid so ignore
             }
-        }
-        return false;
+            return null;
+        });
+        const conflicts = (await Promise.all(checks)).filter((result) => !!result);
+        return conflicts.length > 0 && conflicts;
     }
 }
 exports.default = AddCommandModule;

package/src/commands/update/schematic/schema.d.ts

@@ -45,7 +45,6 @@ export type Schema = {
  */
 export declare enum PackageManager {
     Bun = "bun",
-    Cnpm = "cnpm",
     Npm = "npm",
     Pnpm = "pnpm",
     Yarn = "yarn"

package/src/commands/update/schematic/schema.js

@@ -9,7 +9,6 @@ exports.PackageManager = void 0;
 var PackageManager;
 (function (PackageManager) {
     PackageManager["Bun"] = "bun";
-    PackageManager["Cnpm"] = "cnpm";
     PackageManager["Npm"] = "npm";
     PackageManager["Pnpm"] = "pnpm";
     PackageManager["Yarn"] = "yarn";

package/src/commands/update/schematic/schema.json

@@ -57,7 +57,7 @@
       "description": "The preferred package manager configuration files to use for registry settings.",
       "type": "string",
       "default": "npm",
-      "enum": ["npm", "yarn", "cnpm", "pnpm", "bun"]
+      "enum": ["npm", "yarn", "pnpm", "bun"]
     }
   },
   "required": []

package/src/utilities/version.js

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