@nx/angular 24.0.0-pr.37405.acdaf31 → 24.0.0-rc.0

package/dist/src/migrations/update-24-0-0/add-ready-when-signal.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const internal_1 = require("@nx/devkit/internal");
+async function update(tree) {
+    return (0, internal_1.addReadyWhenSignalToTargets)(tree, [
+        '@angular/build:dev-server',
+        '@angular-devkit/build-angular:dev-server',
+        '@angular-devkit/build-angular:ssr-dev-server',
+        '@nx/angular:dev-server',
+    ]);
+}

package/dist/src/migrations/update-24-0-0/add-ready-when-signal.md

@@ -0,0 +1,59 @@
+#### Report when Angular dev server targets are ready
+
+Nx now knows when the Angular dev server builders are listening.
+Nx listens for that report only on targets that set `readyWhen: { signal: true }`.
+Tasks that depend on such a target with `waitFor: 'ready'` then start once the server is listening, instead of as soon as the target starts.
+
+This migration sets `readyWhen: { signal: true }` on every target in your projects that uses one of these builders:
+
+- `@angular/build:dev-server`
+- `@angular-devkit/build-angular:dev-server`
+- `@angular-devkit/build-angular:ssr-dev-server`
+- `@nx/angular:dev-server`
+
+A target without its own `executor` is updated too when a `targetDefaults` entry in `nx.json` gives it one of these builders.
+
+The migration leaves a target unchanged in these cases:
+
+- The target already sets `readyWhen`, including `null`.
+- The target sets `continuous: false`, or sets no `continuous` and the `targetDefaults` entry that applies to it sets `continuous: false`. Nx only checks readiness for continuous targets.
+- The `targetDefaults` entry that applies to the target sets `readyWhen`.
+
+#### Sample code changes
+
+##### Before
+
+```json title="apps/app1/project.json"
+{
+  // ...
+  "targets": {
+    "serve": {
+      "continuous": true,
+      "executor": "@angular/build:dev-server",
+      "options": {
+        "buildTarget": "app1:build"
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="apps/app1/project.json" {10-12}
+{
+  // ...
+  "targets": {
+    "serve": {
+      "continuous": true,
+      "executor": "@angular/build:dev-server",
+      "options": {
+        "buildTarget": "app1:build"
+      },
+      "readyWhen": {
+        "signal": true
+      }
+    }
+  }
+}
+```

package/dist/src/migrations/update-24-0-0/remove-scam-generator-defaults.d.ts

@@ -0,0 +1,2 @@
+import { type MigrationReturnObject, type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<MigrationReturnObject>;

package/dist/src/migrations/update-24-0-0/remove-scam-generator-defaults.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const COLLECTION = '@nx/angular';
+const REMOVED_GENERATORS = [
+    'scam',
+    'scam-directive',
+    'scam-pipe',
+    'scam-to-standalone',
+];
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson && removeGeneratorDefaults(nxJson)) {
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    const angularJsonProjects = removeAngularJsonGeneratorDefaults(tree);
+    for (const [projectName, project] of (0, devkit_1.getProjects)(tree)) {
+        // updateProjectConfiguration can't write angular.json projects.
+        if (angularJsonProjects.has(projectName)) {
+            continue;
+        }
+        if (removeGeneratorDefaults(project)) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    return { skipAgentic: true };
+}
+function removeAngularJsonGeneratorDefaults(tree) {
+    if (!tree.exists('angular.json')) {
+        return new Set();
+    }
+    const angularJson = (0, devkit_1.readJson)(tree, 'angular.json');
+    const projects = isRecord(angularJson.projects)
+        ? angularJson.projects
+        : {};
+    let changed = false;
+    for (const project of Object.values(projects)) {
+        if (!isRecord(project)) {
+            continue;
+        }
+        // The Angular CLI uses `schematics`, and Nx also reads `generators`.
+        for (const key of ['schematics', 'generators']) {
+            const config = { generators: project[key] };
+            if (removeGeneratorDefaults(config)) {
+                project[key] = config.generators;
+                changed = true;
+            }
+        }
+    }
+    if (changed) {
+        (0, devkit_1.writeJson)(tree, 'angular.json', angularJson);
+    }
+    return new Set(Object.keys(projects));
+}
+function removeGeneratorDefaults(config) {
+    const { generators } = config;
+    if (!isRecord(generators)) {
+        return false;
+    }
+    let changed = removeKeys(generators, REMOVED_GENERATORS.map((generator) => `${COLLECTION}:${generator}`));
+    const collection = generators[COLLECTION];
+    if (isRecord(collection) && removeKeys(collection, REMOVED_GENERATORS)) {
+        changed = true;
+        if (Object.keys(collection).length === 0) {
+            delete generators[COLLECTION];
+        }
+    }
+    if (changed && Object.keys(generators).length === 0) {
+        // `delete` would keep the old value: updateProjectConfiguration merges into package.json `nx`.
+        config.generators = undefined;
+    }
+    return changed;
+}
+function removeKeys(obj, keys) {
+    const presentKeys = keys.filter((key) => key in obj);
+    for (const key of presentKeys) {
+        delete obj[key];
+    }
+    return presentKeys.length > 0;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/src/migrations/update-24-0-0/remove-scam-generator-defaults.md

@@ -0,0 +1,48 @@
+#### Remove defaults for the removed SCAM generators
+
+Nx v24 removes the generators that created and converted single component Angular modules (SCAMs):
+
+- `@nx/angular:scam`
+- `@nx/angular:scam-directive`
+- `@nx/angular:scam-pipe`
+- `@nx/angular:scam-to-standalone`
+
+Nx no longer reads generator defaults set for them.
+This migration removes those defaults from `nx.json` and from the configuration of every project, including projects defined in `angular.json`.
+It handles both the `"@nx/angular:scam"` key form and the nested `"@nx/angular": { "scam": {} }` form.
+When the removal leaves the `@nx/angular` entry or the whole `generators` object (`schematics` in `angular.json`) empty, the migration removes it too.
+
+The migration doesn't change commands or scripts that run these generators.
+Use the `@nx/angular:component`, `@nx/angular:directive`, or `@nx/angular:pipe` generators instead.
+
+#### Sample code changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "generators": {
+    "@nx/angular:component": {
+      "type": "component"
+    },
+    "@nx/angular:scam": {
+      "type": "component"
+    },
+    "@nx/angular:scam-directive": {
+      "type": "directive"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "generators": {
+    "@nx/angular:component": {
+      "type": "component"
+    }
+  }
+}
+```

package/dist/src/migrations/update-24-0-0/upgrade-to-angular-22-2.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from '@nx/devkit';
+export default function upgradeToAngular222(tree: Tree): Promise<{
+    nextSteps: string[];
+    agentContext: string[];
+}>;

package/dist/src/migrations/update-24-0-0/upgrade-to-angular-22-2.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = upgradeToAngular222;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const internal_2 = require("@nx/js/internal");
+const path_1 = require("path");
+// Keep these versions pinned; versions.ts advances to later Angular versions.
+const ANGULAR_22_2_VERSIONS = {
+    '@angular/core': '~22.2.0',
+    '@angular/animations': '~22.2.0',
+    '@angular/common': '~22.2.0',
+    '@angular/compiler': '~22.2.0',
+    '@angular/compiler-cli': '~22.2.0',
+    '@angular/elements': '~22.2.0',
+    '@angular/forms': '~22.2.0',
+    '@angular/language-service': '~22.2.0',
+    '@angular/localize': '~22.2.0',
+    '@angular/platform-browser': '~22.2.0',
+    '@angular/platform-browser-dynamic': '~22.2.0',
+    '@angular/platform-server': '~22.2.0',
+    '@angular/router': '~22.2.0',
+    '@angular/service-worker': '~22.2.0',
+    '@angular/upgrade': '~22.2.0',
+    '@angular/cli': '~22.2.0',
+    '@angular/build': '~22.2.0',
+    '@angular/pwa': '~22.2.0',
+    '@angular/ssr': '~22.2.0',
+    '@angular-devkit/build-angular': '~22.2.0',
+    '@angular-devkit/core': '~22.2.0',
+    '@angular-devkit/schematics': '~22.2.0',
+    '@angular-devkit/architect': '~0.2202.0',
+    '@angular-devkit/build-webpack': '~0.2202.0',
+    '@schematics/angular': '~22.2.0',
+    '@angular/aria': '~22.2.0',
+    '@angular/cdk': '~22.2.0',
+    '@angular/cdk-experimental': '~22.2.0',
+    '@angular/google-maps': '~22.2.0',
+    '@angular/material': '~22.2.0',
+    '@angular/material-date-fns-adapter': '~22.2.0',
+    '@angular/material-experimental': '~22.2.0',
+    '@angular/material-luxon-adapter': '~22.2.0',
+    '@angular/material-moment-adapter': '~22.2.0',
+    'ng-packagr': '~22.2.0',
+    'zone.js': '~0.16.2',
+};
+const COMPONENT_TESTING_SPECIFIER = /^(@?cypress\/angular|@nx\/angular\/plugins\/component-testing$)/;
+const MODULE_FEDERATION_SPECIFIER = /^(@module-federation\/(enhanced|node)|@nx\/module-federation|@nx\/angular\/(mf|module-federation))(\/|$)/;
+const MARKER_TEXT = /cypress\/angular|module-federation|@nx\/angular\/(mf|plugins\/component-testing)/;
+const NX_WEBPACK_EXECUTORS = new Set([
+    '@nx/angular:webpack-browser',
+    '@nx/angular:webpack-server',
+    '@nx/angular:module-federation-dev-server',
+    '@nx/angular:module-federation-dev-ssr',
+]);
+const WEBPACK_CONFIG_FILE = /^(webpack[\w.-]*|module-federation\.config)\.[cm]?[jt]s$/;
+const RESOLVE_EXTENSIONS = ['.ts', '.js', '.mjs', '.cjs', '.mts', '.cts'];
+const DEPENDENCY_FIELDS = [
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies',
+];
+let ts;
+async function upgradeToAngular222(tree) {
+    const scan = scanWorkspace(tree);
+    const unresolved = [];
+    const moduleFederationConfigs = findModuleFederationConfigs(tree, scan, unresolved);
+    const reasons = [];
+    if (scan.componentTestingFiles.length > 0) {
+        reasons.push(`Cypress component testing (${scan.componentTestingFiles.join(', ')}) fails with the webpack-dev-server 6 that Angular 22.2 installs (https://github.com/cypress-io/cypress/issues/34259)`);
+    }
+    if (moduleFederationConfigs.length > 0) {
+        reasons.push(`Module Federation builds (${moduleFederationConfigs.join(', ')}) fail with the webpack 5.111 that Angular 22.2 installs (https://github.com/module-federation/core/issues/5077)`);
+    }
+    else if (unresolved.length > 0 && scan.moduleFederationFiles.length > 0) {
+        reasons.push(`Module Federation fails with the webpack 5.111 that Angular 22.2 installs (https://github.com/module-federation/core/issues/5077). ${scan.moduleFederationFiles.join(', ')} import it, and the migration could not tell whether an Angular webpack build does: ${unresolved.join('; ')}`);
+    }
+    if (reasons.length > 0) {
+        const nextSteps = [
+            `Kept Angular 22.1. ${reasons.join('. ')}. A later Nx migration updates Angular once these issues are fixed. To update before then, move the Angular packages to 22.2 by hand and work around the issues.`,
+        ];
+        return { nextSteps, agentContext: nextSteps };
+    }
+    const declared = (0, devkit_1.readJson)(tree, 'package.json');
+    const { '@angular/core': core, ...others } = ANGULAR_22_2_VERSIONS;
+    // `@angular/core` goes to `dependencies` when the root does not declare it.
+    (0, devkit_1.addDependenciesToPackageJson)(tree, { '@angular/core': core }, Object.fromEntries(Object.entries(others).filter(([name]) => declared.dependencies?.[name] || declared.devDependencies?.[name])));
+}
+function scanWorkspace(tree) {
+    const scan = {
+        angularJsonPaths: [],
+        workspacePackages: new Set(),
+        declaredDependencies: new Map(),
+        componentTestingFiles: [],
+        moduleFederationFiles: [],
+    };
+    // Shared support libraries and config helpers can hold the imports, so the
+    // whole workspace is scanned.
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        const fileName = (0, path_1.basename)(filePath);
+        if (fileName === 'angular.json') {
+            scan.angularJsonPaths.push(filePath);
+            return;
+        }
+        if (fileName === 'package.json') {
+            // Installs fail on a workspace package.json that doesn't parse, so
+            // skipping one loses no installed or linked package.
+            try {
+                const packageJson = (0, devkit_1.readJson)(tree, filePath);
+                if (typeof packageJson.name === 'string') {
+                    scan.workspacePackages.add(packageJson.name);
+                }
+                scan.declaredDependencies.set((0, path_1.dirname)(filePath), new Set(DEPENDENCY_FIELDS.flatMap((field) => Object.keys(packageJson[field] ?? {}))));
+            }
+            catch { }
+            return;
+        }
+        if (!/\.[cm]?[jt]sx?$/.test(filePath)) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!MARKER_TEXT.test(content)) {
+            return;
+        }
+        const { specifiers } = readModuleSpecifiers(filePath, content);
+        if (specifiers.some((s) => COMPONENT_TESTING_SPECIFIER.test(s))) {
+            scan.componentTestingFiles.push(filePath);
+        }
+        if (specifiers.some((s) => MODULE_FEDERATION_SPECIFIER.test(s))) {
+            scan.moduleFederationFiles.push(filePath);
+        }
+    });
+    return scan;
+}
+// The webpack config files of Angular webpack targets that import Module
+// Federation, following relative imports. An import or config the migration
+// cannot read is recorded in `unresolved`.
+function findModuleFederationConfigs(tree, scan, unresolved) {
+    const configs = new Set();
+    const visited = new Set();
+    const visit = (fromDir, specifier, importer) => {
+        if (MODULE_FEDERATION_SPECIFIER.test(specifier)) {
+            configs.add(importer);
+            return;
+        }
+        if (specifier.startsWith('.')) {
+            const filePath = resolveFile(tree, (0, devkit_1.joinPathFragments)(fromDir, specifier));
+            if (!filePath) {
+                unresolved.push(`${importer} loads "${specifier}", which is missing`);
+                return;
+            }
+            if (visited.has(filePath)) {
+                return;
+            }
+            visited.add(filePath);
+            const { specifiers, computed } = readModuleSpecifiers(filePath, tree.read(filePath, 'utf-8'));
+            if (computed) {
+                unresolved.push(`${filePath} has a computed require or import`);
+            }
+            for (const s of specifiers) {
+                visit((0, path_1.dirname)(filePath), s, filePath);
+            }
+            return;
+        }
+        if (!(0, internal_1.isBuiltinModuleImport)(specifier) &&
+            !isInstalledPackage(tree, fromDir, specifier, scan)) {
+            unresolved.push(`${importer} loads "${specifier}", which is not an installed package`);
+        }
+    };
+    const projectRoots = new Set();
+    const visitTarget = (executor, target, workspaceRoot, projectRoot, label) => {
+        if (!isAngularWebpackExecutor(executor)) {
+            return;
+        }
+        projectRoots.add(projectRoot);
+        for (const options of [
+            target.options,
+            ...Object.values(target.configurations ?? {}),
+        ]) {
+            for (const specifier of getWebpackConfigSpecifiers(executor, options ?? {}, projectRoot)) {
+                visit(workspaceRoot, specifier, label);
+            }
+        }
+    };
+    const targetDefaults = (0, devkit_1.readNxJson)(tree)?.targetDefaults;
+    for (const [projectName, project] of (0, devkit_1.getProjects)(tree)) {
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            const defaults = (0, internal_1.readTargetDefaultsForTarget)(targetName, targetDefaults, target.executor, {
+                projectName,
+                projectNode: {
+                    name: projectName,
+                    type: project.projectType === 'application' ? 'app' : 'lib',
+                    data: project,
+                },
+            });
+            const merged = defaults
+                ? (0, internal_1.mergeTargetConfigurations)(target, defaults)
+                : target;
+            visitTarget(merged.executor, merged, '.', project.root, `${projectName}:${targetName}`);
+        }
+    }
+    for (const angularJsonPath of scan.angularJsonPaths) {
+        let angularJson;
+        try {
+            angularJson = (0, devkit_1.readJson)(tree, angularJsonPath);
+        }
+        catch {
+            unresolved.push(`${angularJsonPath} could not be parsed`);
+            continue;
+        }
+        const workspaceRoot = (0, path_1.dirname)(angularJsonPath);
+        for (const [projectName, project] of Object.entries(angularJson.projects ?? {})) {
+            const projectRoot = (0, devkit_1.joinPathFragments)(workspaceRoot, project.root ?? '');
+            for (const [targetName, target] of Object.entries(project.architect ?? project.targets ?? {})) {
+                visitTarget(target.builder, target, workspaceRoot, projectRoot, `${angularJsonPath} ${projectName}:${targetName}`);
+            }
+        }
+    }
+    // Configs a target does not reference directly, such as a remote's
+    // module-federation.config, are found by name.
+    for (const projectRoot of projectRoots) {
+        for (const child of tree.children(projectRoot)) {
+            if (WEBPACK_CONFIG_FILE.test(child)) {
+                visit(projectRoot, `./${child}`, projectRoot);
+            }
+        }
+    }
+    return [...configs];
+}
+function isAngularWebpackExecutor(executor) {
+    return (!!executor &&
+        (NX_WEBPACK_EXECUTORS.has(executor) ||
+            executor.startsWith('@angular-builders/custom-webpack:') ||
+            executor.startsWith('ngx-build-plus:')));
+}
+// The webpack config modules a target loads, as specifiers relative to the
+// workspace root.
+function getWebpackConfigSpecifiers(executor, options, projectRoot) {
+    const toSpecifier = (path) => `./${path
+        .replace(/^\{workspaceRoot\}\/?/, '')
+        .replace(/\{projectRoot\}/g, projectRoot)}`;
+    const { customWebpackConfig, extraWebpackConfig, plugin } = options;
+    const specifiers = [];
+    if (typeof customWebpackConfig?.path === 'string') {
+        specifiers.push(toSpecifier(customWebpackConfig.path));
+    }
+    else if (customWebpackConfig &&
+        executor.startsWith('@angular-builders/custom-webpack:')) {
+        specifiers.push('./webpack.config.js');
+    }
+    if (typeof extraWebpackConfig === 'string') {
+        specifiers.push(toSpecifier(extraWebpackConfig));
+    }
+    // ngx-build-plus loads a `~` plugin path from the workspace root and
+    // anything else as a module.
+    if (typeof plugin === 'string' && plugin) {
+        specifiers.push(plugin.startsWith('~') ? toSpecifier(plugin.slice(1)) : plugin);
+    }
+    return specifiers;
+}
+function resolveFile(tree, path) {
+    return [
+        path,
+        ...RESOLVE_EXTENSIONS.map((extension) => `${path}${extension}`),
+        ...RESOLVE_EXTENSIONS.map((extension) => (0, devkit_1.joinPathFragments)(path, `index${extension}`)),
+    ].find((candidate) => tree.isFile(candidate));
+}
+// A package installed in a node_modules folder the importer resolves from, or
+// declared by the importer's nearest package.json for Yarn PnP installs, which
+// have no node_modules. A workspace package or path alias points back into the
+// workspace, so it is not one.
+function isInstalledPackage(tree, fromDir, specifier, scan) {
+    const segments = specifier.split('/');
+    const packageName = segments
+        .slice(0, specifier.startsWith('@') ? 2 : 1)
+        .join('/');
+    if (scan.workspacePackages.has(packageName)) {
+        return false;
+    }
+    let nearestPackageJsonChecked = false;
+    for (let dir = fromDir;; dir = (0, path_1.dirname)(dir)) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(dir, 'node_modules', packageName, 'package.json'))) {
+            return true;
+        }
+        const declared = scan.declaredDependencies.get(dir);
+        if (declared && !nearestPackageJsonChecked) {
+            nearestPackageJsonChecked = true;
+            if (declared.has(packageName)) {
+                return true;
+            }
+        }
+        if (dir === '.') {
+            return false;
+        }
+    }
+}
+// Specifiers of `import`/`export ... from`, `import x = require()`,
+// `import()` and `require()`. `computed` is set when an `import()` or
+// `require()` takes a value other than a string literal.
+function readModuleSpecifiers(filePath, content) {
+    ts ??= (0, internal_2.ensureTypescript)();
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const specifiers = [];
+    let computed = false;
+    const visit = (node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            specifiers.push(node.moduleSpecifier.text);
+        }
+        else if (ts.isExternalModuleReference(node) &&
+            ts.isStringLiteral(node.expression)) {
+            specifiers.push(node.expression.text);
+        }
+        else if (ts.isCallExpression(node) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) &&
+                    node.expression.text === 'require'))) {
+            const [argument] = node.arguments;
+            if (argument && ts.isStringLiteralLike(argument)) {
+                specifiers.push(argument.text);
+            }
+            else {
+                computed = true;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return { specifiers, computed };
+}

package/dist/src/migrations/update-24-0-0/upgrade-to-angular-22-2.md

@@ -0,0 +1,46 @@
+#### Upgrade Angular to 22.2
+
+Updates the Angular packages of an Angular 22.1 workspace to 22.2, unless the workspace uses Cypress component testing or webpack Module Federation in an Angular project.
+
+Angular 22.2 installs webpack 5.111 and webpack-dev-server 6 through `@angular-devkit/build-angular`. Cypress rejects that webpack-dev-server when it starts Angular component tests ([cypress-io/cypress#34259](https://github.com/cypress-io/cypress/issues/34259)). Module Federation builds fail on that webpack ([module-federation/core#5077](https://github.com/module-federation/core/issues/5077)). The migration keeps the workspace on Angular 22.1 and reports why when it finds either of these:
+
+- An import from `cypress/angular`, `@cypress/angular` or one of their variants, or from `@nx/angular/plugins/component-testing`, in any file of the workspace.
+- An import from `@module-federation/enhanced`, `@module-federation/node`, `@nx/module-federation`, `@nx/angular/mf` or `@nx/angular/module-federation` in the webpack config of an Angular project.
+
+An Angular project is one with an `@nx/angular` webpack or Module Federation executor, an `@angular-builders/custom-webpack` builder or an `ngx-build-plus` builder. Targets are read from `project.json`, including executors inherited from `targetDefaults`, and from every `angular.json`. The migration reads the webpack configs these targets reference, the `webpack*` and `module-federation.config` files in the project root, and every file they import through a relative path. When a config imports something the migration cannot follow, such as a path alias or a workspace package, a Module Federation import anywhere in the workspace also keeps Angular 22.1.
+
+Rspack builds, Native Federation and `@angular-architects/module-federation` don't hold the update. The last one uses the container plugin built into webpack, which works with webpack 5.111.
+
+The migration updates only the packages that the root `package.json` declares, and a catalog reference is updated in the catalog. `@angular/core` is added to `dependencies` when the root doesn't declare it. A later Nx migration updates a workspace kept on Angular 22.1 once the upstream issues are fixed.
+
+#### Examples
+
+##### Before
+
+```jsonc title="package.json"
+{
+  "dependencies": {
+    "@angular/common": "~22.1.0",
+    "@angular/core": "~22.1.0",
+  },
+  "devDependencies": {
+    "@angular/cli": "~22.1.0",
+    "@angular-devkit/build-angular": "~22.1.0",
+  },
+}
+```
+
+##### After
+
+```jsonc title="package.json"
+{
+  "dependencies": {
+    "@angular/common": "~22.2.0",
+    "@angular/core": "~22.2.0",
+  },
+  "devDependencies": {
+    "@angular/cli": "~22.2.0",
+    "@angular-devkit/build-angular": "~22.2.0",
+  },
+}
+```

package/dist/src/plugins/plugin.js

@@ -138,8 +138,10 @@ async function buildAngularProjects(configFilePath, options, angularWorkspaceRoo
             else if (knownExecutors.build.has(angularTarget.builder)) {
                 await updateBuildTarget(projectName, nxTargetName, targets[nxTargetName], angularTarget, context, angularWorkspaceRoot, project.root, namedInputs);
             }
-            else if (knownExecutors.devServer.has(angularTarget.builder)) {
+            else if (knownExecutors.devServer.has(angularTarget.builder) ||
+                knownExecutors.serveSsr.has(angularTarget.builder)) {
                 targets[nxTargetName].continuous = true;
+                targets[nxTargetName].readyWhen = (0, internal_1.getReadyCheckReadyWhen)('@nx/angular/ready-check', (0, node_path_1.basename)(configFilePath));
                 targets[nxTargetName].metadata.help.example.options = { port: 4201 };
             }
             else if (knownExecutors.extractI18n.has(angularTarget.builder)) {
@@ -153,10 +155,6 @@ async function buildAngularProjects(configFilePath, options, angularWorkspaceRoo
             else if (knownExecutors.server.has(angularTarget.builder)) {
                 updateServerTarget(targets[nxTargetName], angularTarget, context, angularWorkspaceRoot, project.root, namedInputs);
             }
-            else if (knownExecutors.serveSsr.has(angularTarget.builder)) {
-                targets[nxTargetName].continuous = true;
-                targets[nxTargetName].metadata.help.example.options = { port: 4201 };
-            }
             else if (knownExecutors.prerender.has(angularTarget.builder)) {
                 prerenderTargets.push({ target: nxTargetName, project: projectName });
             }

package/dist/src/plugins/utils/dev-server-ready-check.d.ts

@@ -0,0 +1,17 @@
+import { type ServerAddress } from '@nx/devkit/internal';
+import type { AngularProjectConfiguration } from '../plugin';
+export interface AngularWorkspace {
+    projects?: Record<string, AngularProjectConfiguration>;
+}
+/**
+ * Where the dev server of the task's `ng serve` or `ng run` command listens,
+ * resolved the way the Angular CLI and the target's builder resolve it, or
+ * null when nothing can be probed.
+ */
+export declare function getDevServerAddress(options: Record<string, unknown>, workspace: AngularWorkspace, root: string): ServerAddress | null;
+/**
+ * The readyWhen of the inferred dev server targets. Runs in the env and with
+ * the options of the task, resolves the target its `ng` command runs from the
+ * workspace config, and waits for the dev server's port.
+ */
+export declare function waitForAngularDevServer(workspaceConfigPath: string): Promise<void>;