@nx/angular 0.0.0-pr-22179-271588f

package/src/migrations/update-14-2-0/remove-show-circular-dependencies-option.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const executors = [
+    '@angular-devkit/build-angular:browser',
+    '@angular-devkit/build-angular:server',
+    '@nrwl/angular:webpack-browser',
+];
+async function default_1(tree) {
+    executors.forEach((executor) => {
+        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (_options, projectName, targetName, configurationName) => {
+            const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+            const config = configurationName
+                ? projectConfiguration.targets[targetName].configurations[configurationName]
+                : projectConfiguration.targets[targetName].options;
+            delete config.showCircularDependencies;
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        });
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-14-2-0/update-angular-cli.d.ts

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

package/src/migrations/update-14-2-0/update-angular-cli.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const angularCliVersion = '~14.0.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;
+            shouldFormat = true;
+        }
+        else if (json.dependencies?.['@angular/cli']) {
+            json.dependencies['@angular/cli'] = angularCliVersion;
+            shouldFormat = true;
+        }
+        return json;
+    });
+    if (shouldFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = default_1;

package/src/migrations/update-14-2-0/update-libraries-secondary-entrypoints.d.ts

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

package/src/migrations/update-14-2-0/update-libraries-secondary-entrypoints.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const libraryExecutors = [
+    '@angular-devkit/build-angular:ng-packagr',
+    '@nrwl/angular:ng-packagr-lite',
+    '@nrwl/angular:package',
+];
+async function default_1(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [, project] of projects) {
+        if (!Object.values(project.targets ?? {}).some((target) => libraryExecutors.includes(target.executor))) {
+            continue;
+        }
+        (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (filePath) => {
+            if ((0, path_1.basename)(filePath) !== 'package.json' ||
+                (0, devkit_1.normalizePath)(filePath) ===
+                    (0, devkit_1.joinPathFragments)(project.root, 'package.json')) {
+                return;
+            }
+            const json = (0, devkit_1.readJson)(tree, filePath);
+            if (json.ngPackage) {
+                // Migrate ng-packagr config to an ng-packagr config file.
+                const configFilePath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(filePath), 'ng-package.json');
+                (0, devkit_1.writeJson)(tree, configFilePath, json.ngPackage);
+            }
+            // Delete package.json as it is no longer needed in APF 14.
+            tree.delete(filePath);
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-14-2-0/update-ngcc-target.d.ts

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

package/src/migrations/update-14-2-0/update-ngcc-target.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function default_1(tree) {
+    let shouldFormat = false;
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        if (json.scripts?.postinstall?.includes('ngcc ')) {
+            json.scripts.postinstall = json.scripts.postinstall.replace(/(.*)(ngcc --properties es2015 )(.*)/, '$1ngcc --properties es2020 $3');
+            shouldFormat = true;
+        }
+        return json;
+    });
+    if (shouldFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = default_1;

package/src/migrations/update-14-2-0/update-router-initial-navigation.d.ts

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

package/src/migrations/update-14-2-0/update-router-initial-navigation.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const typescript_1 = require("typescript");
+async function default_1(tree) {
+    const printer = (0, typescript_1.createPrinter)();
+    const projects = await getProjectsWithAngularRouter(tree);
+    for (const project of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (filePath) => {
+            // we are only interested in .ts files
+            if (!filePath.endsWith('.ts')) {
+                return;
+            }
+            const content = tree.read(filePath, 'utf-8');
+            const ast = tsquery_1.tsquery.ast(content);
+            const routerModuleForRootCall = getRouterModuleForRootCall(ast);
+            if (!routerModuleForRootCall) {
+                return;
+            }
+            const initialNavigationAssignment = getInitialNavigationAssignment(routerModuleForRootCall.arguments[1]);
+            if (!initialNavigationAssignment) {
+                return;
+            }
+            const updatedInitialNavigationAssignment = printer.printNode(typescript_1.EmitHint.Unspecified, typescript_1.factory.updatePropertyAssignment(initialNavigationAssignment, initialNavigationAssignment.name, typescript_1.factory.createIdentifier(`'enabledBlocking'`)), initialNavigationAssignment.getSourceFile());
+            const updatedContent = `${content.slice(0, initialNavigationAssignment.getStart())}${updatedInitialNavigationAssignment}${content.slice(initialNavigationAssignment.getEnd())}`;
+            tree.write(filePath, updatedContent);
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function getInitialNavigationAssignment(extraOptionsLiteral) {
+    for (const prop of extraOptionsLiteral.properties) {
+        if ((0, typescript_1.isPropertyAssignment)(prop) &&
+            ((0, typescript_1.isIdentifier)(prop.name) || (0, typescript_1.isStringLiteralLike)(prop.name)) &&
+            prop.name.text === 'initialNavigation' &&
+            needsMigration(prop)) {
+            return prop;
+        }
+    }
+    return null;
+}
+async function getProjectsWithAngularRouter(tree) {
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    return Object.entries(projectGraph.dependencies)
+        .filter(([node, dep]) => dep.some(({ target }) => target === 'npm:@angular/router' &&
+        !projectGraph.externalNodes?.[node]))
+        .map(([projectName]) => (0, devkit_1.readProjectConfiguration)(tree, projectName));
+}
+function getRouterModuleForRootCall(sourceFile) {
+    // narrow down call expressions
+    const routerModuleForRootCalls = (0, tsquery_1.tsquery)(sourceFile, 'CallExpression:has(PropertyAccessExpression:has(Identifier[name=RouterModule]):has(Identifier[name=forRoot]))', { visitAllChildren: true });
+    for (const node of routerModuleForRootCalls) {
+        if (isRouterModuleForRoot(node) &&
+            node.arguments.length >= 2 &&
+            (0, typescript_1.isObjectLiteralExpression)(node.arguments[1])) {
+            return node;
+        }
+    }
+    return null;
+}
+function isRouterModuleForRoot(node) {
+    // make sure is not an outer call expression (NgModule call)
+    const routerModuleForRootIdentifier = (0, tsquery_1.tsquery)(node.expression, 'CallExpression > PropertyAccessExpression > Identifier[name=RouterModule] ~ Identifier[name=forRoot]', { visitAllChildren: true })[0];
+    return !!routerModuleForRootIdentifier;
+}
+function needsMigration(node) {
+    return ((0, typescript_1.isStringLiteralLike)(node.initializer) && node.initializer.text === 'enabled');
+}

package/src/migrations/update-14-2-0/update-tsconfig-target.d.ts

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

package/src/migrations/update-14-2-0/update-tsconfig-target.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const path_1 = require("path");
+const jestExecutor = '@nrwl/jest:jest';
+const executors = [
+    '@angular-devkit/build-angular:browser',
+    '@angular-devkit/build-angular:karma',
+    '@angular-devkit/build-angular:ng-packagr',
+    '@nrwl/angular:webpack-browser',
+    '@nrwl/angular:delegate-build',
+    '@nrwl/angular:ng-packagr-lite',
+    '@nrwl/angular:package',
+];
+const skipTargets = ['es2020', 'es2021', 'es2022', 'esnext'];
+async function default_1(tree) {
+    const tsConfigPaths = await collectTsConfigPaths(tree);
+    for (const tsConfigPath of tsConfigPaths) {
+        (0, devkit_2.updateJson)(tree, tsConfigPath, (json) => {
+            if (!json.compilerOptions?.target ||
+                (json.compilerOptions?.target &&
+                    !skipTargets.includes(json.compilerOptions.target.toLowerCase()))) {
+                json.compilerOptions ??= {};
+                json.compilerOptions.target = 'es2020';
+            }
+            return json;
+        }, {
+            allowTrailingComma: true,
+            disallowComments: false,
+        });
+    }
+    await (0, devkit_2.formatFiles)(tree);
+}
+exports.default = default_1;
+async function collectTsConfigPaths(tree) {
+    const uniqueTsConfigs = new Set([]);
+    const projectGraph = await (0, devkit_2.createProjectGraphAsync)();
+    const angularProjects = Object.entries(projectGraph.dependencies)
+        .filter(([node, dep]) => dep.some(({ target }) => target === 'npm:@angular/core' && !projectGraph.externalNodes?.[node]))
+        .map(([projectName]) => ({
+        projectName,
+        project: (0, devkit_2.readProjectConfiguration)(tree, projectName),
+    }));
+    for (const { projectName, project } of angularProjects) {
+        const tsConfigPath = (0, devkit_2.joinPathFragments)(project.root, 'tsconfig.json');
+        if (tree.exists(tsConfigPath)) {
+            uniqueTsConfigs.add(tsConfigPath);
+            const targetTsConfigPaths = getProjectTsConfigPaths(tree, project, projectName, false);
+            targetTsConfigPaths.forEach((tsConfigPath) => {
+                const tsConfig = (0, devkit_1.readJson)(tree, tsConfigPath, {
+                    allowTrailingComma: true,
+                    disallowComments: false,
+                });
+                if (tsConfig.compilerOptions?.target) {
+                    uniqueTsConfigs.add(tsConfigPath);
+                }
+            });
+            continue;
+        }
+        const tsConfigPaths = getProjectTsConfigPaths(tree, project, projectName);
+        for (const tsConfigPath of tsConfigPaths) {
+            uniqueTsConfigs.add(tsConfigPath);
+        }
+    }
+    return Array.from(uniqueTsConfigs);
+}
+function getProjectTsConfigPaths(tree, project, projectName, shouldWarn = true) {
+    const tsConfigPaths = new Set();
+    for (const [targetName, target] of Object.entries(project.targets || {})) {
+        if (executors.includes(target.executor)) {
+            const tsConfigPathsFromTarget = getPathValuesFromTarget(target, 'tsConfig');
+            tsConfigPathsFromTarget.forEach((tsConfigPath) => {
+                if (tree.exists(tsConfigPath)) {
+                    tsConfigPaths.add(tsConfigPath);
+                }
+                else if (shouldWarn) {
+                    devkit_2.logger.warn(`The "${tsConfigPath}" file specified in the "${targetName}" target of the "${projectName}" project could not be found. ` +
+                        'Skipping setting the target to ES2020.');
+                }
+            });
+        }
+        else if (target.executor === jestExecutor) {
+            const tsConfigPathsFromJestTarget = getTsConfigPathsFromJestTarget(tree, target, targetName, projectName, shouldWarn);
+            tsConfigPathsFromJestTarget.forEach((tsConfigPath) => {
+                tsConfigPaths.add(tsConfigPath);
+            });
+        }
+        else if (shouldWarn) {
+            devkit_2.logger.warn(`The "${targetName}" target of the "${projectName}" project is using an executor not supported by the migration. ` +
+                'Skipping setting the TS target to ES2020 for the project.');
+        }
+    }
+    return Array.from(tsConfigPaths);
+}
+function getTsConfigPathsFromJestTarget(tree, target, targetName, projectName, shouldWarn) {
+    const tsConfigPaths = [];
+    const jestConfigPaths = getPathValuesFromTarget(target, 'jestConfig');
+    if (!jestConfigPaths.length && shouldWarn) {
+        devkit_2.logger.warn(`The "${targetName}" target of the "${projectName}" project is using the "${jestExecutor}" executor but no "jestConfig" property was specified. ` +
+            'Skipping setting the TS compilation target to ES2020 for the project.');
+    }
+    for (const jestConfigPath of jestConfigPaths) {
+        const tsConfigPath = getTsConfigFromJestConfig(tree, jestConfigPath, targetName, projectName, shouldWarn);
+        if (tsConfigPath) {
+            tsConfigPaths.push(tsConfigPath);
+        }
+    }
+    return tsConfigPaths;
+}
+function getTsConfigFromJestConfig(tree, jestConfigPath, targetName, projectName, shouldWarn) {
+    if (!tree.exists(jestConfigPath)) {
+        if (shouldWarn) {
+            devkit_2.logger.warn(`The "${jestConfigPath}" file specified in the "${targetName}" target of the "${projectName}" project could not be found. ` +
+                `The TS config file used by the target can't be determined. Skipping setting the target to ES2020.`);
+        }
+        return undefined;
+    }
+    const jestConfig = tree.read(jestConfigPath, 'utf-8');
+    const jestConfigAst = tsquery_1.tsquery.ast(jestConfig);
+    const tsJestTsConfigStringLiteral = (0, tsquery_1.tsquery)(jestConfigAst, 'PropertyAssignment:has(Identifier[name=globals]) PropertyAssignment:has(StringLiteral[value=ts-jest]) PropertyAssignment Identifier[name=tsconfig] ~ StringLiteral', { visitAllChildren: true })[0];
+    if (!tsJestTsConfigStringLiteral) {
+        if (shouldWarn) {
+            devkit_2.logger.warn(`Couldn't find the "tsconfig" property for "ts-jest" in the Jest configuration file "${jestConfigPath}" specified in the ` +
+                `"${targetName}" target of the "${projectName}" project. The TS config file used by the target can't be determined. ` +
+                'Skipping setting the target to ES2020.');
+        }
+        return undefined;
+    }
+    const tsJestTsConfigValue = tsJestTsConfigStringLiteral
+        .getText()
+        .replace(/['"]/g, '');
+    const tsConfigPath = tsJestTsConfigValue.replace('<rootDir>', (0, path_1.dirname)(jestConfigPath));
+    if (!tree.exists(tsConfigPath)) {
+        if (shouldWarn) {
+            devkit_2.logger.warn(`The "${tsJestTsConfigValue}" file specified in the Jest configuration file "${jestConfigPath}" of the "${targetName}" target ` +
+                `of the "${projectName}" project could not be found. Skipping setting the target to ES2020.`);
+        }
+        return undefined;
+    }
+    return tsConfigPath;
+}
+function getPathValuesFromTarget(target, option) {
+    const values = [];
+    if (target.options?.[option]) {
+        values.push(target.options[option]);
+    }
+    Object.values(target.configurations ?? {}).forEach((options) => {
+        if (options[option]) {
+            values.push(options[option]);
+        }
+    });
+    return values;
+}

package/src/migrations/update-14-5-0/migrate-mfe-to-mf.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '@nx/devkit';
+export declare function replaceNrwlAngularMfImport(fileContents: string): string;
+export declare function replaceExportedMFETypes(fileContents: string): string;
+export declare function renameSetupMfeGeneratorUsages(fileContents: string): string;
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-14-5-0/migrate-mfe-to-mf.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameSetupMfeGeneratorUsages = exports.replaceExportedMFETypes = exports.replaceNrwlAngularMfImport = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const NRWL_ANGULAR_MFE_STATIC_IMPORT_SELECTOR = 'ImportDeclaration > StringLiteral[value="@nrwl/angular/mfe"]';
+const NRWL_ANGULAR_MFE_DYNAMIC_IMPORT_SELECTOR = 'CallExpression:has(ImportKeyword) > StringLiteral[value="@nrwl/angular/mfe"]';
+const NRWL_ANGULAR_MFE_TYPES_SELECTOR = 'ImportDeclaration:has(StringLiteral[value=@nrwl/angular/module-federation]) > ImportClause > NamedImports';
+function replaceNrwlAngularMfImport(fileContents) {
+    let fileAst = tsquery_1.tsquery.ast(fileContents);
+    if (fileContents.includes('@nrwl/angular/mfe')) {
+        // This file definitely contains the string, however, we're interested in whether it is an import
+        const staticQueryResult = (0, tsquery_1.tsquery)(fileAst, NRWL_ANGULAR_MFE_STATIC_IMPORT_SELECTOR, {
+            visitAllChildren: true,
+        });
+        if (staticQueryResult && staticQueryResult.length > 0) {
+            fileContents = `${fileContents.slice(0, staticQueryResult[0].getStart())}'@nrwl/angular/mf'${fileContents.slice(staticQueryResult[0].getEnd())}`;
+        }
+        fileAst = tsquery_1.tsquery.ast(fileContents);
+        const dynamicQueryResult = (0, tsquery_1.tsquery)(fileAst, NRWL_ANGULAR_MFE_DYNAMIC_IMPORT_SELECTOR, {
+            visitAllChildren: true,
+        });
+        if (dynamicQueryResult && dynamicQueryResult.length > 0) {
+            fileContents = `${fileContents.slice(0, dynamicQueryResult[0].getStart())}'@nrwl/angular/mf'${fileContents.slice(dynamicQueryResult[0].getEnd())}`;
+        }
+    }
+    return fileContents;
+}
+exports.replaceNrwlAngularMfImport = replaceNrwlAngularMfImport;
+function replaceExportedMFETypes(fileContents) {
+    const ast = tsquery_1.tsquery.ast(fileContents);
+    const queryResult = (0, tsquery_1.tsquery)(ast, NRWL_ANGULAR_MFE_TYPES_SELECTOR, {
+        visitAllChildren: true,
+    });
+    if (queryResult && queryResult.length > 0) {
+        const TYPES_IMPORTED_FROM_NRWL_REGEX = /(MFERemotes|MFEConfig)+.*from+.+(@nrwl\/angular\/module-federation)+/g;
+        if (TYPES_IMPORTED_FROM_NRWL_REGEX.test(fileContents)) {
+            fileContents = fileContents.replace(/MFERemotes/g, 'MFRemotes');
+            fileContents = fileContents.replace(/MFEConfig/g, 'MFConfig');
+        }
+    }
+    return fileContents;
+}
+exports.replaceExportedMFETypes = replaceExportedMFETypes;
+function renameSetupMfeGeneratorUsages(fileContents) {
+    // Attempt to update any custom generator usage of the changed generators
+    const NRWL_SETUP_MFE_IMPORT_SELECTOR = 'ImportDeclaration:has(StringLiteral[value=@nrwl/angular/generators]) > ImportClause:has(NamedImports:has(ImportSpecifier > Identifier[name=setupMfe]))';
+    const SETUP_MFE_IMPORTED_FROM_NRWL_REGEX = /(setupMfe)+.*from+.+(@nrwl\/angular\/generators)+/g;
+    const SETUP_MFE_FUNCTION_CALL_MFE_TYPE_PROPERTY_ASSIGNMENT_SELECTOR = 'CallExpression:has(Identifier[name=setupMf]) ObjectLiteralExpression > PropertyAssignment > Identifier[name=mfeType]';
+    let ast = tsquery_1.tsquery.ast(fileContents);
+    let queryResult = (0, tsquery_1.tsquery)(ast, NRWL_SETUP_MFE_IMPORT_SELECTOR, {
+        visitAllChildren: true,
+    });
+    if (queryResult &&
+        queryResult.length > 0 &&
+        SETUP_MFE_IMPORTED_FROM_NRWL_REGEX.test(fileContents)) {
+        fileContents = fileContents.replace(/setupMfe/g, 'setupMf');
+    }
+    ast = tsquery_1.tsquery.ast(fileContents);
+    queryResult = (0, tsquery_1.tsquery)(ast, SETUP_MFE_FUNCTION_CALL_MFE_TYPE_PROPERTY_ASSIGNMENT_SELECTOR, {
+        visitAllChildren: true,
+    });
+    while (queryResult && queryResult.length > 0) {
+        const node = queryResult[0];
+        fileContents = `${fileContents.slice(0, node.getStart())}mfType${fileContents.slice(node.getEnd())}`;
+        ast = tsquery_1.tsquery.ast(fileContents);
+        queryResult = (0, tsquery_1.tsquery)(ast, SETUP_MFE_FUNCTION_CALL_MFE_TYPE_PROPERTY_ASSIGNMENT_SELECTOR, {
+            visitAllChildren: true,
+        });
+    }
+    return fileContents;
+}
+exports.renameSetupMfeGeneratorUsages = renameSetupMfeGeneratorUsages;
+async function default_1(tree) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '/', (path) => {
+        const pathExtName = (0, path_1.extname)(path);
+        if (pathExtName !== '.ts' && pathExtName !== '.js') {
+            return;
+        }
+        let fileContents = tree.read(path, 'utf-8');
+        fileContents = replaceNrwlAngularMfImport(fileContents);
+        if (pathExtName === '.ts') {
+            // Only TS files can import types and interfaces
+            fileContents = replaceExportedMFETypes(fileContents);
+            fileContents = renameSetupMfeGeneratorUsages(fileContents);
+        }
+        tree.write(path, fileContents);
+    });
+}
+exports.default = default_1;

package/src/migrations/update-14-5-2/update-angular-cli.d.ts

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

package/src/migrations/update-14-5-2/update-angular-cli.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const angularCliVersion = '~14.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;
+            shouldFormat = true;
+        }
+        else if (json.dependencies?.['@angular/cli']) {
+            json.dependencies['@angular/cli'] = angularCliVersion;
+            shouldFormat = true;
+        }
+        return json;
+    });
+    if (shouldFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = default_1;

package/src/migrations/update-14-6-0/update-angular-cli.d.ts

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

package/src/migrations/update-14-6-0/update-angular-cli.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const angularCliVersion = '~14.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;
+            shouldFormat = true;
+        }
+        else if (json.dependencies?.['@angular/cli']) {
+            json.dependencies['@angular/cli'] = angularCliVersion;
+            shouldFormat = true;
+        }
+        return json;
+    });
+    if (shouldFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = default_1;

package/src/migrations/update-14-8-0/rename-webpack-server.d.ts

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

package/src/migrations/update-14-8-0/rename-webpack-server.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+function renameWebpackServer(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const oldExecutorName = '@nrwl/angular:webpack-server';
+    const newExecutorName = '@nrwl/angular:webpack-dev-server';
+    for (const [projectName, project] of projects.entries()) {
+        let stringifiedProject = JSON.stringify(project);
+        if (!stringifiedProject.includes(oldExecutorName)) {
+            continue;
+        }
+        for (const [targetName, target] of Object.entries(project.targets)) {
+            if (target.executor === oldExecutorName) {
+                target.executor = newExecutorName;
+            }
+        }
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+    }
+}
+exports.default = renameWebpackServer;

package/src/migrations/update-15-0-0/add-karma-inputs.d.ts

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

package/src/migrations/update-15-0-0/add-karma-inputs.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const karmaTargets = getKarmaTargetNames(tree);
+    const hasProductionFileset = !!nxJson.namedInputs?.production;
+    if (karmaTargets.size > 0 && hasProductionFileset) {
+        const productionFileset = new Set(nxJson.namedInputs.production);
+        for (const exclusion of [
+            '!{projectRoot}/**/*.spec.[jt]s',
+            '!{projectRoot}/tsconfig.spec.json',
+            '!{projectRoot}/karma.conf.js',
+        ]) {
+            productionFileset.add(exclusion);
+        }
+        nxJson.namedInputs.production = Array.from(productionFileset);
+    }
+    for (const targetName of karmaTargets) {
+        nxJson.targetDefaults ??= {};
+        const jestTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
+        jestTargetDefaults.inputs ??= [
+            'default',
+            hasProductionFileset ? '^production' : '^default',
+            ...(tree.exists('karma.conf.js')
+                ? ['{workspaceRoot}/karma.conf.js']
+                : []),
+        ];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function getKarmaTargetNames(tree) {
+    const karmaTargetNames = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@angular-devkit/build-angular:karma', (_, __, target) => {
+        karmaTargetNames.add(target);
+    });
+    return karmaTargetNames;
+}

package/src/migrations/update-15-0-0/switch-to-jasmine-marbles.d.ts

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