@nx/angular 0.0.0-pr-31222-862e973 → 0.0.0-pr-31313-387cdca

package/src/migrations/update-20-2-0/migrate-mf-imports-to-new-package.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateMfImportsToNewPackage;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const MF_IMPORT_TO_UPDATE = 'ModuleFederationConfig';
+const MF_CONFIG_IMPORT_SELECTOR = `ImportDeclaration:has(StringLiteral[value=@nx/webpack]):has(Identifier[name=ModuleFederationConfig])`;
+const IMPORT_TOKENS_SELECTOR = `ImportClause ImportSpecifier`;
+const MF_CONFIG_IMPORT_SPECIFIER_SELECTOR = `ImportClause ImportSpecifier > Identifier[name=ModuleFederationConfig]`;
+const WEBPACK_IMPORT_SELECTOR = `ImportDeclaration > StringLiteral[value=@nx/webpack]`;
+async function migrateMfImportsToNewPackage(tree) {
+    const rootsToCheck = new Set();
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    for (const [project, dependencies] of Object.entries(graph.dependencies)) {
+        if (!graph.nodes[project]) {
+            continue;
+        }
+        const usesNxWebpack = dependencies.some((dep) => dep.target === 'npm:@nx/webpack');
+        if (usesNxWebpack) {
+            const root = graph.nodes[project].data.root;
+            rootsToCheck.add(root);
+        }
+    }
+    for (const root of rootsToCheck) {
+        (0, devkit_2.visitNotIgnoredFiles)(tree, root, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes(MF_IMPORT_TO_UPDATE)) {
+                return;
+            }
+            const ast = tsquery_1.tsquery.ast(contents);
+            const importNodes = (0, tsquery_1.tsquery)(ast, MF_CONFIG_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            const importNode = importNodes[0];
+            const importSpecifiers = (0, tsquery_1.tsquery)(importNode, IMPORT_TOKENS_SELECTOR);
+            if (importSpecifiers.length > 1) {
+                const mfConfigImportSpecifierNode = (0, tsquery_1.tsquery)(importNode, MF_CONFIG_IMPORT_SPECIFIER_SELECTOR)[0];
+                const end = contents.charAt(mfConfigImportSpecifierNode.getEnd()) === ','
+                    ? mfConfigImportSpecifierNode.getEnd() + 1
+                    : mfConfigImportSpecifierNode.getEnd();
+                contents = `import { ${MF_IMPORT_TO_UPDATE} } from '@nx/module-federation';
+      ${contents.slice(0, mfConfigImportSpecifierNode.getStart())}${contents.slice(end)}`;
+            }
+            else {
+                const nxWebpackImportStringNodes = (0, tsquery_1.tsquery)(ast, WEBPACK_IMPORT_SELECTOR);
+                if (nxWebpackImportStringNodes.length === 0) {
+                    return;
+                }
+                const nxWebpackImportStringNode = nxWebpackImportStringNodes[0];
+                contents = `${contents.slice(0, nxWebpackImportStringNode.getStart())}'@nx/module-federation'${contents.slice(nxWebpackImportStringNode.getEnd())}`;
+            }
+            tree.write(filePath, contents);
+        });
+    }
+    await (0, devkit_2.formatFiles)(tree);
+}

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.d.ts

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

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateWithMfImport;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const versions_1 = require("../../utils/versions");
+const NX_ANGULAR_MODULE_FEDERATION_IMPORT_SELECTOR = 'ImportDeclaration > StringLiteral[value=@nx/angular/module-federation], VariableStatement CallExpression:has(Identifier[name=require]) > StringLiteral[value=@nx/angular/module-federation]';
+const NEW_IMPORT_PATH = `'@nx/module-federation/angular'`;
+async function migrateWithMfImport(tree) {
+    const projects = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/angular:webpack-browser', (options, project, target) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+        projects.add(projectConfig.root);
+    });
+    for (const projectRoot of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectRoot, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes('@nx/angular/module-federation')) {
+                return;
+            }
+            const ast = tsquery_1.tsquery.ast(contents);
+            const importNodes = (0, tsquery_1.tsquery)(ast, NX_ANGULAR_MODULE_FEDERATION_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            const importPathNode = importNodes[0];
+            contents = `${contents.slice(0, importPathNode.getStart())}${NEW_IMPORT_PATH}${contents.slice(importPathNode.getEnd())}`;
+            tree.write(filePath, contents);
+        });
+    }
+    if (projects.size !== 0) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/module-federation': versions_1.nxVersion,
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/migrations/update-20-2-0/remove-angular-eslint-rules.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const rulesToRemove: string[];
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-20-2-0/remove-angular-eslint-rules.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rulesToRemove = void 0;
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
+const projects_1 = require("../utils/projects");
+exports.rulesToRemove = [
+    '@angular-eslint/no-host-metadata-property',
+    '@angular-eslint/sort-ngmodule-metadata-arrays',
+    '@angular-eslint/prefer-standalone-component',
+];
+async function default_1(tree) {
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, [
+        'npm:@angular/core',
+    ]);
+    let hasRootProject = false;
+    for (const { project: { root }, } of projects) {
+        if (!(0, eslint_file_1.isEslintConfigSupported)(tree, root)) {
+            // ESLint config is not supported, skip
+            continue;
+        }
+        if (root === '.') {
+            hasRootProject = true;
+        }
+        removeRules(tree, root);
+    }
+    /**
+     * We need to handle both a root config file (e.g. eslint.config.js) and a
+     * potential base config file (e.g. eslint.base.config.js). We can't use
+     * `findEslintFile` because it would return only one or the other depending
+     * on whether a root is provided and the existence of the files. So, we
+     * handle each of them separately.
+     */
+    // check root config, provide a root so it doesn't try to lookup a base config
+    if (!hasRootProject) {
+        // if there is no root project the root eslint config has not been processed
+        if ((0, eslint_file_1.isEslintConfigSupported)(tree, '')) {
+            removeRules(tree, '');
+        }
+    }
+    // handle root base config, not providing a root will prioritize a base config
+    const baseEslintConfig = (0, eslint_file_1.findEslintFile)(tree);
+    if (baseEslintConfig && baseEslintConfig.includes('.base.')) {
+        removeRules(tree, baseEslintConfig);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function removeRules(tree, root) {
+    for (const rule of exports.rulesToRemove) {
+        const lookup = (o) => !!o.rules?.[rule];
+        if (!(0, eslint_file_1.lintConfigHasOverride)(tree, root, lookup)) {
+            // it's not using the rule, skip
+            continue;
+        }
+        // there is an override containing the rule, remove the rule
+        (0, eslint_file_1.updateOverrideInLintConfig)(tree, root, lookup, (o) => {
+            delete o.rules[rule];
+            return o;
+        });
+    }
+}

package/src/migrations/update-20-2-0/remove-tailwind-config-from-ng-packagr-executors.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const executors: string[];
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-20-2-0/remove-tailwind-config-from-ng-packagr-executors.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executors = void 0;
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+exports.executors = ['@nx/angular:ng-packagr-lite', '@nx/angular:package'];
+async function default_1(tree) {
+    // update options from project configs
+    exports.executors.forEach((executor) => {
+        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (options, project, target, configuration) => {
+            if (options.tailwindConfig === undefined) {
+                return;
+            }
+            const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, project);
+            if (configuration) {
+                const config = projectConfiguration.targets[target].configurations[configuration];
+                delete config.tailwindConfig;
+                if (!Object.keys(config).length) {
+                    delete projectConfiguration.targets[target].configurations[configuration];
+                }
+                if (!Object.keys(projectConfiguration.targets[target].configurations)
+                    .length) {
+                    delete projectConfiguration.targets[target].configurations;
+                }
+            }
+            else {
+                const config = projectConfiguration.targets[target].options;
+                delete config.tailwindConfig;
+                if (!Object.keys(config).length) {
+                    delete projectConfiguration.targets[target].options;
+                }
+            }
+            (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfiguration);
+        });
+    });
+    // update options from nx.json target defaults
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson.targetDefaults) {
+        return;
+    }
+    for (const [targetOrExecutor, targetConfig] of Object.entries(nxJson.targetDefaults)) {
+        if (!exports.executors.includes(targetOrExecutor) &&
+            !exports.executors.includes(targetConfig.executor)) {
+            continue;
+        }
+        if (targetConfig.options) {
+            delete targetConfig.options.tailwindConfig;
+            if (!Object.keys(targetConfig.options).length) {
+                delete targetConfig.options;
+            }
+        }
+        Object.entries(targetConfig.configurations ?? {}).forEach(([name, config]) => {
+            delete config.tailwindConfig;
+            if (!Object.keys(config).length) {
+                delete targetConfig.configurations[name];
+            }
+        });
+        if (!Object.keys(targetConfig.configurations ?? {}).length) {
+            delete targetConfig.configurations;
+        }
+        if (!Object.keys(targetConfig).length ||
+            (Object.keys(targetConfig).length === 1 &&
+                Object.keys(targetConfig)[0] === 'executor')) {
+            delete nxJson.targetDefaults[targetOrExecutor];
+        }
+        if (!Object.keys(nxJson.targetDefaults).length) {
+            delete nxJson.targetDefaults;
+        }
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/migrations/{update-14-5-2 → update-20-2-0}/update-angular-cli.d.ts

@@ -1,2 +1,3 @@
 import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~19.0.0";
 export default function (tree: Tree): Promise<void>;

package/src/migrations/{update-16-1-0 → update-20-2-0}/update-angular-cli.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.angularCliVersion = void 0;
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
-exports.angularCliVersion = '~16.0.0';
+exports.angularCliVersion = '~19.0.0';
 async function default_1(tree) {
     let shouldFormat = false;
     (0, devkit_1.updateJson)(tree, 'package.json', (json) => {

package/src/migrations/{update-14-2-0/update-libraries-secondary-entrypoints.d.ts → update-20-2-0/update-angular-ssr-imports-to-use-node-entry-point.d.ts}

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

package/src/migrations/update-20-2-0/update-angular-ssr-imports-to-use-node-entry-point.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const ts = tslib_1.__importStar(require("typescript"));
+const file_change_recorder_1 = require("../../utils/file-change-recorder");
+const projects_1 = require("../utils/projects");
+async function default_1(tree) {
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, [
+        'npm:@angular/ssr',
+    ]);
+    for (const { project } of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (path) => {
+            if (!path.endsWith('.ts') || path.endsWith('.d.ts')) {
+                return;
+            }
+            let content = tree.read(path, 'utf-8');
+            if (!content.includes('CommonEngine') ||
+                content.includes('@angular/ssr/node')) {
+                return;
+            }
+            let recorder;
+            const sourceFile = ts.createSourceFile(path, content, ts.ScriptTarget.Latest, true);
+            const allImportDeclarations = sourceFile.statements.filter(ts.isImportDeclaration);
+            if (allImportDeclarations.length === 0) {
+                return;
+            }
+            const ssrImports = allImportDeclarations.filter((n) => ts.isStringLiteral(n.moduleSpecifier) &&
+                n.moduleSpecifier.text === '@angular/ssr');
+            for (const ssrImport of ssrImports) {
+                const ssrNamedBinding = getNamedImports(ssrImport);
+                if (ssrNamedBinding) {
+                    const isUsingOldEntryPoint = ssrNamedBinding.elements.some((e) => e.name.text.startsWith('CommonEngine'));
+                    if (!isUsingOldEntryPoint) {
+                        continue;
+                    }
+                    recorder ??= new file_change_recorder_1.FileChangeRecorder(tree, path);
+                    recorder.insertRight(ssrImport.moduleSpecifier.getEnd() - 1, '/node');
+                }
+            }
+            if (recorder) {
+                recorder.applyChanges();
+            }
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function getNamedImports(importDeclaration) {
+    const namedBindings = importDeclaration?.importClause?.namedBindings;
+    if (namedBindings && ts.isNamedImports(namedBindings)) {
+        return namedBindings;
+    }
+    return undefined;
+}

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.d.ts

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

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ensureMfPackage;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const versions_1 = require("../../utils/versions");
+async function ensureMfPackage(tree) {
+    const projects = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/angular:module-federation-dev-server', (options, project, target) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+        projects.add(projectConfig.root);
+    });
+    if (projects.size !== 0) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/module-federation': versions_1.nxVersion,
+        });
+    }
+}

package/src/migrations/{update-14-2-0 → update-20-4-0}/update-angular-cli.d.ts

@@ -1,2 +1,3 @@
 import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~19.1.0";
 export default function (tree: Tree): Promise<void>;

package/src/migrations/{update-14-2-0 → update-20-4-0}/update-angular-cli.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularCliVersion = void 0;
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
-const angularCliVersion = '~14.0.0';
+exports.angularCliVersion = '~19.1.0';
 async function default_1(tree) {
     let shouldFormat = false;
     (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
         if (json.devDependencies?.['@angular/cli']) {
-            json.devDependencies['@angular/cli'] = angularCliVersion;
+            json.devDependencies['@angular/cli'] = exports.angularCliVersion;
             shouldFormat = true;
         }
         else if (json.dependencies?.['@angular/cli']) {
-            json.dependencies['@angular/cli'] = angularCliVersion;
+            json.dependencies['@angular/cli'] = exports.angularCliVersion;
             shouldFormat = true;
         }
         return json;

package/src/migrations/{update-14-6-0 → update-20-5-0}/update-angular-cli.d.ts

@@ -1,2 +1,3 @@
 import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~19.2.0";
 export default function (tree: Tree): Promise<void>;

package/src/migrations/{update-14-5-2 → update-20-5-0}/update-angular-cli.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularCliVersion = void 0;
 exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
-const angularCliVersion = '~14.1.0';
+exports.angularCliVersion = '~19.2.0';
 async function default_1(tree) {
     let shouldFormat = false;
     (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
         if (json.devDependencies?.['@angular/cli']) {
-            json.devDependencies['@angular/cli'] = angularCliVersion;
+            json.devDependencies['@angular/cli'] = exports.angularCliVersion;
             shouldFormat = true;
         }
         else if (json.dependencies?.['@angular/cli']) {
-            json.dependencies['@angular/cli'] = angularCliVersion;
+            json.dependencies['@angular/cli'] = exports.angularCliVersion;
             shouldFormat = true;
         }
         return json;

package/src/migrations/{update-14-2-0/update-ngcc-target.d.ts → update-21-0-0/change-data-persistence-operators-imports-to-ngrx-router-store-data-persistence.d.ts}

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

package/src/migrations/update-21-0-0/change-data-persistence-operators-imports-to-ngrx-router-store-data-persistence.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const project_graph_1 = require("nx/src/config/project-graph");
+const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
+const version_utils_1 = require("../../generators/utils/version-utils");
+const file_change_recorder_1 = require("../../utils/file-change-recorder");
+const projects_1 = require("../utils/projects");
+let tsquery;
+const angularPluginTargetNames = ['npm:@nx/angular', 'npm:@nrwl/angular'];
+const dataPersistenceOperators = [
+    'fetch',
+    'navigation',
+    'optimisticUpdate',
+    'pessimisticUpdate',
+];
+const newImportPath = '@ngrx/router-store/data-persistence';
+async function default_1(tree) {
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, angularPluginTargetNames);
+    if (!projects.length) {
+        return;
+    }
+    (0, ensure_typescript_1.ensureTypescript)();
+    tsquery = require('@phenomnomnominal/tsquery').tsquery;
+    const cachedFileMap = (0, nx_deps_cache_1.readFileMapCache)().fileMap.projectFileMap;
+    const filesWithNxAngularImports = [];
+    for (const { graphNode } of projects) {
+        const files = filterFilesWithNxAngularDep(cachedFileMap[graphNode.name] || []);
+        filesWithNxAngularImports.push(...files);
+    }
+    let isAnyFileUsingDataPersistence = false;
+    for (const { file } of filesWithNxAngularImports) {
+        const updated = replaceDataPersistenceInFile(tree, file);
+        isAnyFileUsingDataPersistence ||= updated;
+    }
+    if (isAnyFileUsingDataPersistence) {
+        addNgrxRouterStoreIfNotInstalled(tree);
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+function replaceDataPersistenceInFile(tree, file) {
+    const fileContents = tree.read(file, 'utf-8');
+    const fileAst = tsquery.ast(fileContents);
+    // "\\u002F" is the unicode code for "/", there's an issue with the query parser
+    // that prevents using "/" directly in regex queries
+    // https://github.com/estools/esquery/issues/68#issuecomment-415597670
+    const NX_ANGULAR_IMPORT_SELECTOR = 'ImportDeclaration:has(StringLiteral[value=/@(nx|nrwl)\\u002Fangular$/])';
+    const nxAngularImports = tsquery(fileAst, NX_ANGULAR_IMPORT_SELECTOR, { visitAllChildren: true });
+    if (!nxAngularImports.length) {
+        return false;
+    }
+    const recorder = new file_change_recorder_1.FileChangeRecorder(tree, file);
+    const IMPORT_SPECIFIERS_SELECTOR = 'ImportClause NamedImports ImportSpecifier';
+    for (const importDeclaration of nxAngularImports) {
+        const importSpecifiers = tsquery(importDeclaration, IMPORT_SPECIFIERS_SELECTOR, { visitAllChildren: true });
+        if (!importSpecifiers.length) {
+            continue;
+        }
+        // no imported symbol is a data persistence operator, skip
+        if (importSpecifiers.every((i) => !isOperatorImport(i))) {
+            continue;
+        }
+        // all imported symbols are data persistence operators, change import path
+        if (importSpecifiers.every((i) => isOperatorImport(i))) {
+            const IMPORT_PATH_SELECTOR = `${NX_ANGULAR_IMPORT_SELECTOR} > StringLiteral`;
+            const importPathNode = tsquery(importDeclaration, IMPORT_PATH_SELECTOR, {
+                visitAllChildren: true,
+            });
+            recorder.replace(importPathNode[0], `'${newImportPath}'`);
+            continue;
+        }
+        // mixed imports, split data persistence operators to a separate import
+        const operatorImportSpecifiers = [];
+        for (const importSpecifier of importSpecifiers) {
+            if (isOperatorImport(importSpecifier)) {
+                operatorImportSpecifiers.push(importSpecifier.getText());
+                recorder.remove(importSpecifier.getStart(), importSpecifier.getEnd() +
+                    (hasTrailingComma(recorder.originalContent, importSpecifier)
+                        ? 1
+                        : 0));
+            }
+        }
+        recorder.insertLeft(importDeclaration.getStart(), `import { ${operatorImportSpecifiers.join(', ')} } from '${newImportPath}';`);
+    }
+    if (recorder.hasChanged()) {
+        recorder.applyChanges();
+        return true;
+    }
+    return false;
+}
+function hasTrailingComma(content, node) {
+    return content[node.getEnd()] === ',';
+}
+function isOperatorImport(importSpecifier) {
+    return dataPersistenceOperators.includes(getOriginalIdentifierTextFromImportSpecifier(importSpecifier));
+}
+function getOriginalIdentifierTextFromImportSpecifier(importSpecifier) {
+    const children = importSpecifier.getChildren();
+    if (!children.length) {
+        return importSpecifier.getText();
+    }
+    return children[0].getText();
+}
+function addNgrxRouterStoreIfNotInstalled(tree) {
+    const { dependencies, devDependencies } = (0, devkit_1.readJson)(tree, 'package.json');
+    if (dependencies?.['@ngrx/router-store'] ||
+        devDependencies?.['@ngrx/router-store']) {
+        return;
+    }
+    (0, devkit_1.addDependenciesToPackageJson)(tree, { '@ngrx/router-store': (0, version_utils_1.versions)(tree).ngrxVersion }, {});
+}
+function filterFilesWithNxAngularDep(files) {
+    const filteredFiles = [];
+    for (const file of files) {
+        if (file.deps?.some((dep) => angularPluginTargetNames.includes((0, project_graph_1.fileDataDepTarget)(dep)))) {
+            filteredFiles.push(file);
+        }
+    }
+    return filteredFiles;
+}

package/src/migrations/update-21-0-0/set-continuous-option.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const continuousExecutors: Set<string>;
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-21-0-0/set-continuous-option.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continuousExecutors = void 0;
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+exports.continuousExecutors = new Set([
+    '@angular-devkit/build-angular:dev-server',
+    '@angular-devkit/build-angular:ssr-dev-server',
+    '@nx/angular:dev-server',
+    '@nx/angular:module-federation-dev-server',
+    '@nx/angular:module-federation-dev-ssr',
+]);
+async function default_1(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, projectConfig] of projects) {
+        let updated = false;
+        for (const targetConfig of Object.values(projectConfig.targets ?? {})) {
+            if (exports.continuousExecutors.has(targetConfig.executor) &&
+                targetConfig.continuous === undefined) {
+                targetConfig.continuous = true;
+                updated = true;
+            }
+        }
+        if (updated) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/plugins/plugin.js

@@ -19,6 +19,7 @@ const knownExecutors = {
         '@angular-devkit/build-angular:browser-esbuild',
         '@angular-devkit/build-angular:browser',
         '@angular-devkit/build-angular:ng-packagr',
+        '@angular/build:ng-packagr',
     ]),
     devServer: new Set(['@angular-devkit/build-angular:dev-server']),
     extractI18n: new Set(['@angular-devkit/build-angular:extract-i18n']),
@@ -113,6 +114,7 @@ async function buildAngularProjects(configFilePath, options, angularWorkspaceRoo
                 await updateBuildTarget(nxTargetName, targets[nxTargetName], angularTarget, context, angularWorkspaceRoot, project.root, namedInputs);
             }
             else if (knownExecutors.devServer.has(angularTarget.builder)) {
+                targets[nxTargetName].continuous = true;
                 targets[nxTargetName].metadata.help.example.options = { port: 4201 };
             }
             else if (knownExecutors.extractI18n.has(angularTarget.builder)) {
@@ -127,6 +129,7 @@ async function buildAngularProjects(configFilePath, options, angularWorkspaceRoo
                 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)) {
@@ -201,7 +204,8 @@ async function updateBuildTarget(targetName, target, angularTarget, context, ang
             getOutput(fullOutputPath, context.workspaceRoot, angularWorkspaceRoot, projectRoot),
         ];
     }
-    else if (angularTarget.builder === '@angular-devkit/build-angular:ng-packagr') {
+    else if (angularTarget.builder === '@angular-devkit/build-angular:ng-packagr' ||
+        angularTarget.builder === '@angular/build:ng-packagr') {
         const outputs = await getNgPackagrOutputs(angularTarget, angularWorkspaceRoot, projectRoot, context);
         if (outputs.length) {
             target.outputs = outputs;
@@ -215,7 +219,8 @@ async function updateBuildTarget(targetName, target, angularTarget, context, ang
                 ? ['production', '^production']
                 : ['default', '^default'];
     }
-    if (angularTarget.builder === '@angular-devkit/build-angular:ng-packagr') {
+    if (angularTarget.builder === '@angular-devkit/build-angular:ng-packagr' ||
+        angularTarget.builder === '@angular/build:ng-packagr') {
         target.metadata.help.example.options = { watch: true };
     }
     else {

package/src/utils/backward-compatible-versions.d.ts

@@ -1,11 +1,11 @@
 import * as latestVersions from './versions';
-type SupportedVersions = 'angularV16' | 'angularV17';
+type SupportedVersions = 'angularV17' | 'angularV18';
 type LatestPackageVersionNames = Exclude<keyof typeof latestVersions, 'nxVersion'>;
-type CompatPackageVersionNames = LatestPackageVersionNames | 'ngUniversalVersion';
+type CompatPackageVersionNames = LatestPackageVersionNames;
 export type PackageVersionNames = LatestPackageVersionNames | CompatPackageVersionNames;
 export type VersionMap = {
-    angularV16: Record<Exclude<CompatPackageVersionNames, 'typescriptEslintVersion'>, string>;
-    angularV17: Record<Exclude<CompatPackageVersionNames, 'ngUniversalVersion' | 'typescriptEslintVersion'>, string>;
+    angularV17: Record<Exclude<CompatPackageVersionNames, 'typescriptEslintVersion'>, string>;
+    angularV18: Record<CompatPackageVersionNames, string>;
 };
 export type PackageLatestVersions = Record<LatestPackageVersionNames, string>;
 export type PackageCompatVersions = VersionMap[SupportedVersions];