@nx/angular 21.1.1 → 21.2.0-beta.1

package/src/migrations/update-21-2-0/migrate-provide-server-rendering-import.js

@@ -0,0 +1,110 @@
+"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 versions_1 = require("../../utils/versions");
+const projects_1 = require("../utils/projects");
+async function default_1(tree) {
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, [
+        'npm:@angular/platform-server',
+    ]);
+    if (!projects.length) {
+        return;
+    }
+    let isSsrInstalled = false;
+    for (const { project } of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (file) => {
+            if (!file.endsWith('.ts') || file.endsWith('.d.ts')) {
+                return;
+            }
+            const shouldInstallSsr = processFile(tree, file);
+            if (shouldInstallSsr && !isSsrInstalled) {
+                isSsrInstalled = true;
+                (0, devkit_1.addDependenciesToPackageJson)(tree, { '@angular/ssr': versions_1.angularDevkitVersion }, {}, undefined, true);
+            }
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function processFile(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content.includes('provideServerRendering') ||
+        !content.includes('@angular/platform-server')) {
+        return false;
+    }
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    let platformServerHasProvideServerRendering = false;
+    let platformServerImportNode;
+    let ssrImportNode;
+    const platformServerImports = new Set();
+    sourceFile.forEachChild((node) => {
+        if (!ts.isImportDeclaration(node)) {
+            return;
+        }
+        const moduleSpecifier = node.moduleSpecifier.getText(sourceFile);
+        if (moduleSpecifier.includes('@angular/platform-server')) {
+            platformServerImportNode = node;
+            const importClause = node.importClause;
+            if (importClause &&
+                importClause.namedBindings &&
+                ts.isNamedImports(importClause.namedBindings)) {
+                const namedImports = importClause.namedBindings.elements.map((e) => e.getText(sourceFile));
+                namedImports.forEach((importName) => {
+                    if (importName === 'provideServerRendering') {
+                        platformServerHasProvideServerRendering = true;
+                    }
+                    else {
+                        platformServerImports.add(importName);
+                    }
+                });
+            }
+        }
+        else if (moduleSpecifier.includes('@angular/ssr')) {
+            ssrImportNode = node;
+        }
+    });
+    if (!platformServerHasProvideServerRendering) {
+        return;
+    }
+    const recorder = new file_change_recorder_1.FileChangeRecorder(tree, filePath);
+    const printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+    });
+    if (ssrImportNode?.importClause?.namedBindings &&
+        ts.isNamedImports(ssrImportNode.importClause.namedBindings)) {
+        const namedBindingsNode = ssrImportNode.importClause
+            .namedBindings;
+        const updatedNamedBindingsNode = ts.factory.updateNamedImports(namedBindingsNode, [
+            ...namedBindingsNode.elements,
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('provideServerRendering')),
+        ]);
+        recorder.replace(namedBindingsNode, printer.printNode(ts.EmitHint.Unspecified, updatedNamedBindingsNode, sourceFile));
+    }
+    else {
+        /**
+         * Add a new import statement with the needed named import in case it
+         * doesn't exist yet or it doesn't have named imports.
+         *
+         * It would be quite uncommon to have an import from @angular/ssr without
+         * named imports, but if that's the case, we'll just add an extra import
+         * statement with the needed named import.
+         */
+        recorder.insertLeft(0, `import { provideServerRendering } from '@angular/ssr';\n`);
+    }
+    if (platformServerImports.size > 0) {
+        // we only collected platform server imports because there were named
+        // imports, so we can safely use the type
+        const namedBindingsNode = platformServerImportNode.importClause
+            .namedBindings;
+        const updatedNamedBindingsNode = ts.factory.updateNamedImports(namedBindingsNode, namedBindingsNode.elements.filter((e) => platformServerImports.has(e.getText(sourceFile))));
+        recorder.replace(namedBindingsNode, printer.printNode(ts.EmitHint.Unspecified, updatedNamedBindingsNode, sourceFile));
+    }
+    else {
+        recorder.remove(platformServerImportNode.getFullStart(), platformServerImportNode.getEnd());
+    }
+    recorder.applyChanges();
+    return true;
+}

package/src/migrations/update-21-2-0/replace-provide-server-routing.d.ts

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

package/src/migrations/update-21-2-0/replace-provide-server-routing.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+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',
+    ]);
+    if (!projects.length) {
+        return;
+    }
+    for (const { project } of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (file) => {
+            if (!file.endsWith('.ts') || file.endsWith('.d.ts')) {
+                return;
+            }
+            processFile(tree, file);
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function processFile(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content.includes('provideServerRouting') ||
+        !content.includes('@angular/ssr')) {
+        return;
+    }
+    const sourceFile = tsquery_1.tsquery.ast(content);
+    const providersArray = tsquery_1.tsquery.query(sourceFile, 'PropertyAssignment:has(Identifier[name=providers]) > ArrayLiteralExpression:has(CallExpression > Identifier[name=provideServerRouting])', { visitAllChildren: true })[0];
+    if (!providersArray) {
+        return;
+    }
+    const recorder = new file_change_recorder_1.FileChangeRecorder(tree, filePath);
+    const printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+    });
+    let provideServerRenderingCall;
+    let provideServerRoutingCall;
+    const providerCallNodes = providersArray.elements.filter((el) => ts.isCallExpression(el));
+    for (const node of providerCallNodes) {
+        if (node.expression.getText() === 'provideServerRendering') {
+            provideServerRenderingCall = node;
+        }
+        else if (node.expression.getText() === 'provideServerRouting') {
+            provideServerRoutingCall = node;
+        }
+    }
+    const withRoutesCall = ts.factory.createCallExpression(ts.factory.createIdentifier('withRoutes'), undefined, [provideServerRoutingCall.arguments.at(0)]);
+    let updatedProvidersArray;
+    if (provideServerRenderingCall) {
+        // remove the "provideServerRouting" call and update the existing "provideServerRendering" call
+        updatedProvidersArray = ts.factory.updateArrayLiteralExpression(providersArray, providersArray.elements
+            .filter((el) => !(ts.isCallExpression(el) &&
+            ts.isIdentifier(el.expression) &&
+            el.expression.text === 'provideServerRouting'))
+            .map((el) => {
+            if (ts.isCallExpression(el) &&
+                ts.isIdentifier(el.expression) &&
+                el.expression.text === 'provideServerRendering') {
+                return ts.factory.updateCallExpression(el, el.expression, el.typeArguments, [withRoutesCall, ...provideServerRoutingCall.arguments.slice(1)]);
+            }
+            return el;
+        }));
+    }
+    else {
+        // replace the "provideServerRouting" call with the new "provideServerRendering" call
+        updatedProvidersArray = ts.factory.updateArrayLiteralExpression(providersArray, providersArray.elements.map((el) => {
+            if (ts.isCallExpression(el) &&
+                ts.isIdentifier(el.expression) &&
+                el.expression.text === 'provideServerRouting') {
+                return ts.factory.createCallExpression(ts.factory.createIdentifier('provideServerRendering'), undefined, [withRoutesCall, ...provideServerRoutingCall.arguments.slice(1)]);
+            }
+            return el;
+        }));
+    }
+    recorder.replace(providersArray, printer.printNode(ts.EmitHint.Unspecified, updatedProvidersArray, sourceFile));
+    const importDecl = sourceFile.statements.find((stmt) => ts.isImportDeclaration(stmt) &&
+        ts.isStringLiteral(stmt.moduleSpecifier) &&
+        stmt.moduleSpecifier.text === '@angular/ssr');
+    if (importDecl?.importClause?.namedBindings) {
+        const namedBindings = importDecl?.importClause.namedBindings;
+        if (ts.isNamedImports(namedBindings)) {
+            // remove the "provideServerRouting" import and ensure we have the "withRoutes" import
+            const updatedElementNames = new Set([
+                ...namedBindings.elements
+                    .map((el) => el.getText())
+                    .filter((x) => x !== 'provideServerRouting'),
+                'withRoutes',
+            ]);
+            const updatedNamedBindings = ts.factory.updateNamedImports(namedBindings, Array.from(updatedElementNames).map((name) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(name))));
+            const printer = ts.createPrinter({
+                newLine: ts.NewLineKind.LineFeed,
+            });
+            recorder.replace(namedBindings, printer.printNode(ts.EmitHint.Unspecified, updatedNamedBindings, sourceFile));
+        }
+    }
+    recorder.applyChanges();
+}

package/src/migrations/update-21-2-0/set-generator-defaults-for-previous-style-guide.d.ts

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

package/src/migrations/update-21-2-0/set-generator-defaults-for-previous-style-guide.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const TYPE_GENERATORS = ['component', 'directive', 'service'];
+const TYPE_SEPARATOR_GENERATORS = [
+    'guard',
+    'interceptor',
+    'module',
+    'pipe',
+    'resolver',
+];
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.generators ??= {};
+    for (const generator of TYPE_GENERATORS) {
+        setDefault(nxJson.generators, '@nx/angular', generator, 'type', generator);
+        setDefault(nxJson.generators, '@schematics/angular', generator, 'type', generator);
+    }
+    setDefault(nxJson.generators, '@nx/angular', 'scam', 'type', 'component');
+    setDefault(nxJson.generators, '@nx/angular', 'scam-directive', 'type', 'directive');
+    for (const generator of TYPE_SEPARATOR_GENERATORS) {
+        setDefault(nxJson.generators, '@nx/angular', generator, 'typeSeparator', '.');
+        setDefault(nxJson.generators, '@schematics/angular', generator, 'typeSeparator', '.');
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+function setDefault(generators, collection, generator, option, value) {
+    const generatorKey = `${collection}:${generator}`;
+    if (generators[generatorKey]?.[option] ||
+        generators[collection]?.[generator]?.[option]) {
+        return;
+    }
+    if (generators[generatorKey]) {
+        generators[generatorKey][option] = value;
+    }
+    else if (generators[collection]?.[generator]) {
+        generators[collection][generator][option] = value;
+    }
+    else if (generators[collection]) {
+        generators[collection][generator] = { [option]: value };
+    }
+    else {
+        generators[generatorKey] = { [option]: value };
+    }
+}

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

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

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

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

package/src/migrations/update-21-2-0/update-module-resolution.d.ts

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

package/src/migrations/update-21-2-0/update-module-resolution.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const targets_1 = require("../../utils/targets");
+const projects_1 = require("../utils/projects");
+async function default_1(tree) {
+    const uniqueTsConfigs = new Set();
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, [
+        'npm:@angular/core',
+    ]);
+    for (const { project } of projects) {
+        for (const [, target] of (0, targets_1.allProjectTargets)(project)) {
+            for (const [, options] of (0, targets_1.allTargetOptions)(target)) {
+                if (typeof options?.tsConfig === 'string') {
+                    uniqueTsConfigs.add(options.tsConfig);
+                }
+            }
+        }
+    }
+    for (const tsConfig of uniqueTsConfigs) {
+        if (tree.exists(tsConfig)) {
+            updateModuleResolution(tree, tsConfig);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function updateModuleResolution(tree, tsConfigPath) {
+    const tsConfig = (0, devkit_1.readJson)(tree, tsConfigPath);
+    if (!tsConfig.compilerOptions) {
+        return;
+    }
+    const { compilerOptions } = tsConfig;
+    // Only update if module is not 'preserve' and moduleResolution is not already 'bundler'
+    if (compilerOptions.module === 'preserve' ||
+        compilerOptions.moduleResolution === 'bundler') {
+        return;
+    }
+    // Update moduleResolution to 'bundler'
+    (0, devkit_1.updateJson)(tree, tsConfigPath, (json) => {
+        json.compilerOptions ??= {};
+        json.compilerOptions.moduleResolution = 'bundler';
+        return json;
+    });
+}

package/src/plugins/plugin.js

@@ -21,8 +21,14 @@ const knownExecutors = {
         '@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']),
+    devServer: new Set([
+        '@angular-devkit/build-angular:dev-server',
+        '@angular/build:dev-server',
+    ]),
+    extractI18n: new Set([
+        '@angular-devkit/build-angular:extract-i18n',
+        '@angular/build:extract-i18n',
+    ]),
     prerender: new Set([
         '@angular-devkit/build-angular:prerender',
         '@nguniversal/builders:prerender',
@@ -32,7 +38,10 @@ const knownExecutors = {
         '@angular-devkit/build-angular:ssr-dev-server',
         '@nguniversal/builders:ssr-dev-server',
     ]),
-    test: new Set(['@angular-devkit/build-angular:karma']),
+    test: new Set([
+        '@angular-devkit/build-angular:karma',
+        '@angular/build:karma',
+    ]),
 };
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 function readProjectsCache(cachePath) {
@@ -111,7 +120,7 @@ async function buildAngularProjects(configFilePath, options, angularWorkspaceRoo
                 appShellTargets.push({ target: nxTargetName, project: projectName });
             }
             else if (knownExecutors.build.has(angularTarget.builder)) {
-                await updateBuildTarget(nxTargetName, targets[nxTargetName], angularTarget, context, angularWorkspaceRoot, project.root, namedInputs);
+                await updateBuildTarget(projectName, nxTargetName, targets[nxTargetName], angularTarget, context, angularWorkspaceRoot, project.root, namedInputs);
             }
             else if (knownExecutors.devServer.has(angularTarget.builder)) {
                 targets[nxTargetName].continuous = true;
@@ -196,21 +205,21 @@ function updateAppShellTarget(projectName, targetName, projects, angularJson, an
     target.inputs = inputs;
     target.outputs = outputs;
 }
-async function updateBuildTarget(targetName, target, angularTarget, context, angularWorkspaceRoot, projectRoot, namedInputs) {
+async function updateBuildTarget(projectName, targetName, target, angularTarget, context, angularWorkspaceRoot, projectRoot, namedInputs) {
     target.dependsOn = [`^${targetName}`];
-    if (angularTarget.options?.outputPath) {
-        const fullOutputPath = (0, node_path_1.join)(context.workspaceRoot, angularWorkspaceRoot, angularTarget.options.outputPath);
-        target.outputs = [
-            getOutput(fullOutputPath, context.workspaceRoot, angularWorkspaceRoot, projectRoot),
-        ];
-    }
-    else if (angularTarget.builder === '@angular-devkit/build-angular:ng-packagr' ||
+    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;
         }
     }
+    else {
+        const fullOutputPath = (0, node_path_1.join)(context.workspaceRoot, angularWorkspaceRoot, angularTarget.options?.outputPath ?? posix.join('dist', projectName));
+        target.outputs = [
+            getOutput(fullOutputPath, context.workspaceRoot, angularWorkspaceRoot, projectRoot),
+        ];
+    }
     if (target.outputs?.length) {
         // make it cacheable if we were able to identify outputs
         target.cache = true;
@@ -272,7 +281,7 @@ function updatePrerenderTarget(projectName, targetName, projects, angularJson) {
     target.outputs = outputs;
 }
 async function getNgPackagrOutputs(target, angularWorkspaceRoot, projectRoot, context) {
-    let ngPackageJsonPath = (0, node_path_1.join)(context.workspaceRoot, angularWorkspaceRoot, target.options.project);
+    let ngPackageJsonPath = (0, node_path_1.join)(context.workspaceRoot, angularWorkspaceRoot, target.options?.project ?? (0, node_path_1.join)(projectRoot, 'ng-package.json'));
     const readConfig = async (configPath) => {
         if (!(0, node_fs_1.existsSync)(configPath)) {
             return undefined;

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

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

package/src/utils/backward-compatible-versions.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.backwardCompatibleVersions = void 0;
 exports.backwardCompatibleVersions = {
-    angularV17: {
-        angularVersion: '~17.3.0',
-        angularDevkitVersion: '~17.3.0',
-        ngPackagrVersion: '~17.3.0',
+    angularV18: {
+        angularVersion: '~18.2.0',
+        angularDevkitVersion: '~18.2.0',
+        ngPackagrVersion: '~18.2.0',
         angularRspackVersion: '~20.6.1',
-        ngrxVersion: '~17.0.0',
+        ngrxVersion: '~18.0.2',
         rxjsVersion: '~7.8.0',
         zoneJsVersion: '~0.14.3',
         angularJsVersion: '1.7.9',
@@ -17,27 +17,29 @@ exports.backwardCompatibleVersions = {
         expressVersion: '^4.21.2',
         typesExpressVersion: '^4.17.21',
         browserSyncVersion: '^3.0.0',
-        moduleFederationNodeVersion: '~2.3.0',
-        moduleFederationEnhancedVersion: '~0.2.3',
-        angularEslintVersion: '~17.3.0',
+        moduleFederationNodeVersion: '~2.5.0',
+        moduleFederationEnhancedVersion: '0.6.9',
+        angularEslintVersion: '^18.3.0',
+        typescriptEslintVersion: '^7.16.0',
         tailwindVersion: '^3.0.2',
         postcssVersion: '^8.4.5',
         postcssUrlVersion: '~10.1.3',
         autoprefixerVersion: '^10.4.0',
         tsNodeVersion: '10.9.1',
-        jestPresetAngularVersion: '~14.0.3',
+        jestPresetAngularVersion: '~14.1.0',
         typesNodeVersion: '18.16.9',
         jasmineMarblesVersion: '^0.9.2',
         jsoncEslintParserVersion: '^2.1.0',
+        webpackMergeVersion: '^5.8.0',
     },
-    angularV18: {
-        angularVersion: '~18.2.0',
-        angularDevkitVersion: '~18.2.0',
-        ngPackagrVersion: '~18.2.0',
+    angularV19: {
+        angularVersion: '~19.2.0',
+        angularDevkitVersion: '~19.2.0',
+        ngPackagrVersion: '~19.2.0',
         angularRspackVersion: '~20.6.1',
-        ngrxVersion: '~18.0.2',
+        ngrxVersion: '~19.1.0',
         rxjsVersion: '~7.8.0',
-        zoneJsVersion: '~0.14.3',
+        zoneJsVersion: '~0.15.0',
         angularJsVersion: '1.7.9',
         tsLibVersion: '^2.3.0',
         corsVersion: '~2.8.5',
@@ -45,18 +47,19 @@ exports.backwardCompatibleVersions = {
         expressVersion: '^4.21.2',
         typesExpressVersion: '^4.17.21',
         browserSyncVersion: '^3.0.0',
-        moduleFederationNodeVersion: '~2.5.0',
-        moduleFederationEnhancedVersion: '0.6.9',
-        angularEslintVersion: '^18.3.0',
+        moduleFederationNodeVersion: '^2.6.26',
+        moduleFederationEnhancedVersion: '^0.9.0',
+        angularEslintVersion: '^19.2.0',
         typescriptEslintVersion: '^7.16.0',
         tailwindVersion: '^3.0.2',
         postcssVersion: '^8.4.5',
         postcssUrlVersion: '~10.1.3',
         autoprefixerVersion: '^10.4.0',
         tsNodeVersion: '10.9.1',
-        jestPresetAngularVersion: '~14.1.0',
+        jestPresetAngularVersion: '~14.4.0',
         typesNodeVersion: '18.16.9',
         jasmineMarblesVersion: '^0.9.2',
         jsoncEslintParserVersion: '^2.1.0',
+        webpackMergeVersion: '^5.8.0',
     },
 };

package/src/utils/nx-devkit/ast-utils.js

@@ -444,9 +444,18 @@ function getListOfRoutes(source) {
 }
 function isNgStandaloneApp(tree, projectName) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
-    const mainFile = project.targets?.build?.options?.main ??
+    let mainFile = project.targets?.build?.options?.main ??
         project.targets?.build?.options?.browser;
-    if (project.projectType !== 'application' || !mainFile) {
+    let hasMainFile = false;
+    if (mainFile) {
+        hasMainFile = true;
+    }
+    else {
+        const sourceRoot = project.sourceRoot ?? (0, devkit_1.joinPathFragments)(project.root, 'src');
+        mainFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'main.ts');
+        hasMainFile = tree.exists(mainFile);
+    }
+    if (project.projectType !== 'application' || !hasMainFile) {
         return false;
     }
     (0, ensure_typescript_1.ensureTypescript)();
@@ -548,7 +557,12 @@ function readBootstrapInfo(host, app) {
     let mainPath;
     try {
         mainPath =
-            config.targets.build.options.main ?? config.targets.build.options.browser;
+            config.targets.build.options?.main ??
+                config.targets.build.options?.browser;
+        if (!mainPath) {
+            const sourceRoot = config.sourceRoot ?? (0, devkit_1.joinPathFragments)(config.root, 'src');
+            mainPath = (0, devkit_1.joinPathFragments)(sourceRoot, 'main.ts');
+        }
     }
     catch (e) {
         throw new Error('Main file cannot be located');

package/src/utils/nx-devkit/testing.js

@@ -18,24 +18,24 @@ function createApp(tree, appName, routing = true) {
     // save for getAppDir() lookup by external *.spec.ts tests
     appConfig = {
         appName,
-        appModule: `${appName}/src/app/app.module.ts`,
+        appModule: `${appName}/src/app/app-module.ts`,
     };
     tree.write(appConfig.appModule, `import { NgModule } from '@angular/core';
 import { BrowserModule } from '@angular/platform-browser';
 ${routing ? "import { RouterModule } from '@angular/router'" : ''};
-import { AppComponent } from './app.component';
+import { App } from './app';
 @NgModule({
   imports: [BrowserModule, ${routing ? 'RouterModule.forRoot([])' : ''}],
-  declarations: [AppComponent],
-  bootstrap: [AppComponent]
+  declarations: [App],
+  bootstrap: [App]
 })
 export class AppModule {}
 `);
-    tree.write(`${appName}/src/main.ts`, `import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+    tree.write(`${appName}/src/main.ts`, `import { platformBrowser } from '@angular/platform-browser';
 
-import { AppModule } from './app/app.module';
+import { AppModule } from './app/app-module';
 
-platformBrowserDynamic()
+platformBrowser()
   .bootstrapModule(AppModule)
   .catch(err => console.log(err));
   `);
@@ -65,7 +65,7 @@ function createLib(tree, libName) {
     const { name, className, fileName, propertyName } = (0, devkit_1.names)(libName);
     libConfig = {
         name,
-        module: `${propertyName}/src/lib/${fileName}.module.ts`,
+        module: `${propertyName}/src/lib/${fileName}-module.ts`,
         barrel: `${propertyName}/src/index.ts`,
     };
     tree.write(libConfig.module, `import { NgModule } from '@angular/core';
@@ -78,6 +78,6 @@ import { CommonModule } from '@angular/common';
 })
 export class ${className}Module { }
   `);
-    tree.write(libConfig.barrel, `export * from './lib/${fileName}.module';
+    tree.write(libConfig.barrel, `export * from './lib/${fileName}-module';
 `);
 }

package/src/utils/targets.d.ts

@@ -1,2 +1,3 @@
-import { TargetConfiguration } from '@nx/devkit';
+import type { ProjectConfiguration, TargetConfiguration } from '@nx/devkit';
+export declare function allProjectTargets<T>(project: ProjectConfiguration): Iterable<[name: string, target: TargetConfiguration<T>]>;
 export declare function allTargetOptions<T>(target: TargetConfiguration<T>): Iterable<[string | undefined, T]>;

package/src/utils/targets.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.allProjectTargets = allProjectTargets;
 exports.allTargetOptions = allTargetOptions;
+function* allProjectTargets(project) {
+    for (const [name, target] of Object.entries(project.targets ?? {})) {
+        yield [name, target];
+    }
+}
 function* allTargetOptions(target) {
     if (target.options) {
         yield [undefined, target.options];

package/src/utils/versions.d.ts

@@ -1,7 +1,7 @@
 export declare const nxVersion: any;
-export declare const angularVersion = "~19.2.0";
-export declare const angularDevkitVersion = "~19.2.0";
-export declare const ngPackagrVersion = "~19.2.0";
+export declare const angularVersion = "20.0.0-rc.2";
+export declare const angularDevkitVersion = "20.0.0-rc.3";
+export declare const ngPackagrVersion = "20.0.0-rc.1";
 export declare const angularRspackVersion = "^21.0.1";
 export declare const ngrxVersion = "^19.0.0";
 export declare const rxjsVersion = "~7.8.0";
@@ -15,6 +15,7 @@ export declare const typesExpressVersion = "^4.17.21";
 export declare const browserSyncVersion = "^3.0.0";
 export declare const moduleFederationNodeVersion = "^2.6.26";
 export declare const moduleFederationEnhancedVersion = "^0.9.0";
+export declare const webpackMergeVersion = "^5.8.0";
 export declare const angularEslintVersion = "^19.2.0";
 export declare const typescriptEslintVersion = "^7.16.0";
 export declare const tailwindVersion = "^3.0.2";