@nx/angular 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/dist/src/generators/scam-to-standalone/scam-to-standalone.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scamToStandalone = scamToStandalone;
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const lib_1 = require("./lib");
+/**
+ * @deprecated SCAMs are superseded by Angular standalone components. Convert any remaining SCAMs before upgrading. It will be removed in Nx v24.
+ */
+async function scamToStandalone(tree, { component, project: projectName, skipFormat }) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    const projects = (0, devkit_1.getProjects)(tree);
+    let project = (0, lib_1.getTargetProject)(projectName, projects);
+    const normalizedComponentPath = (0, devkit_1.joinPathFragments)(project.root, component);
+    if (!tree.exists(normalizedComponentPath)) {
+        throw new Error(`The path provided to the component (${normalizedComponentPath}) does not exist. Please ensure the correct path has been provided.`);
+    }
+    const { componentFileContents, componentAST, componentName } = (0, lib_1.getComponentDataFromAST)(tree, normalizedComponentPath);
+    const isInlineScam = (0, lib_1.verifyIsInlineScam)(componentAST);
+    if (!isInlineScam) {
+        throw new Error('This generator currently only supports inline SCAMs. We could not find an accompanying NgModule within the component file, please ensure the SCAM provided is an inline scam.');
+    }
+    const { moduleNodes, exportsArray, importsArray, declarationsArray, providersArray, moduleName, } = (0, lib_1.getModuleMetadataFromAST)(componentAST, componentFileContents);
+    (0, lib_1.verifyModuleIsScam)(exportsArray, componentName, declarationsArray);
+    (0, lib_1.convertScamToStandalone)(componentAST, componentFileContents, importsArray, providersArray, moduleNodes, tree, normalizedComponentPath, componentName);
+    (0, lib_1.replaceModuleUsagesWithComponent)(tree, moduleName, componentName);
+    if (!skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = scamToStandalone;

package/dist/src/generators/setup-mf/files/ts-webpack/module-federation.config.ts__tmpl__

@@ -0,0 +1,27 @@
+import type { ModuleFederationConfig } from '@nx/module-federation';
+
+const config: ModuleFederationConfig = {
+  name: '<%= name %>',<% if(type === 'host') { %>
+  /**
+   * To use a remote that does not exist in your current Nx Workspace
+   * You can use the tuple-syntax to define your remote
+   *
+   * remotes: [['my-external-remote', 'https://nx-angular-remote.netlify.app']]
+   *
+   * You _may_ need to add a `remotes.d.ts` file to your `src/` folder declaring the external remote for tsc, with the
+   * following content:
+   *
+   * declare module 'my-external-remote';
+   *
+   */
+  remotes: [<% if (federationType === 'static') { remotes.forEach(function(remote) { %>'<%= remote.remoteName %>',<% }); } %>]<% } %><% if(type === 'remote') { %>
+  exposes: {<% if(standalone) { %>
+    './Routes': '<%= projectRoot %>/src/app/remote-entry/entry.routes.ts',<% } else { %>
+    './Module': '<%= projectRoot %>/src/app/remote-entry/<%= entryModuleFileName %>.ts',<% } %>
+  },<% } %>
+};
+
+/**
+* Nx requires a default export of the config to allow correct resolution of the module federation graph.
+**/
+export default config;

package/dist/src/generators/setup-mf/lib/add-cypress-workaround.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function addCypressOnErrorWorkaround(tree: Tree, schema: Schema): void;

package/dist/src/generators/setup-mf/lib/add-cypress-workaround.js

@@ -0,0 +1,52 @@
+"use strict";
+// This is a temporary workaround to prevent cypress erroring
+// as Angular attempt to figure out how to fix HMR when styles.js
+// is attached to the index.html with type=module
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCypressOnErrorWorkaround = addCypressOnErrorWorkaround;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+function addCypressOnErrorWorkaround(tree, schema) {
+    if (!schema.e2eProjectName) {
+        return;
+    }
+    const e2eProjectName = schema.e2eProjectName;
+    let e2eProject;
+    try {
+        e2eProject = (0, devkit_1.readProjectConfiguration)(tree, e2eProjectName);
+    }
+    catch {
+        devkit_1.logger.warn((0, devkit_1.stripIndents) `Could not find an associated e2e project for ${schema.appName} with name ${e2eProjectName}.
+    If there is an associated e2e project for this application, and it uses Cypress, you will need to add a workaround to allow Cypress to test correctly.
+    An error will be thrown in the console when you serve the application, coming from styles.js. It is an error that can be safely ignored and will not reach production due to how production builds of Angular are created.
+    You can find how to implement that workaround here: https://docs.cypress.io/api/events/catalog-of-events#Uncaught-Exceptions
+    `);
+        return;
+    }
+    if (e2eProject.targets?.e2e?.executor !== '@nx/cypress:cypress') {
+        try {
+            // don't ensure package is installed, if it's not installed, we don't need to add the workaround
+            const { CYPRESS_CONFIG_FILE_NAME_PATTERN, } = require('@nx/cypress/internal');
+            if (!(0, devkit_1.glob)(tree, [`${e2eProject.root}/${CYPRESS_CONFIG_FILE_NAME_PATTERN}`])
+                .length) {
+                // Not a cypress e2e project, skip
+                return;
+            }
+        }
+        catch {
+            // assume cypress is not installed
+            return;
+        }
+    }
+    const commandToAdd = `Cypress.on('uncaught:exception', err => {
+    if (err.message.includes(\`Cannot use 'import.meta' outside a module\`)) {
+      return false;
+    }
+    return true;
+  });`;
+    const pathToCommandsFile = (0, devkit_1.joinPathFragments)((0, internal_1.getProjectSourceRoot)(e2eProject, tree), 'support/e2e.ts');
+    const commandsContent = tree.exists(pathToCommandsFile)
+        ? tree.read(pathToCommandsFile, 'utf-8')
+        : '';
+    tree.write(pathToCommandsFile, `${commandsContent}\n${commandToAdd}`);
+}

package/dist/src/generators/setup-mf/lib/add-remote-entry.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function addRemoteEntry(tree: Tree, options: NormalizedOptions, appRoot: string): void;

package/dist/src/generators/setup-mf/lib/add-remote-to-host.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@nx/devkit';
+export type AddRemoteOptions = {
+    host: string;
+    appName: string;
+    standalone: boolean;
+    port: number;
+};
+export declare function checkIsCommaNeeded(mfRemoteText: string): boolean;
+export declare function addRemoteToHost(tree: Tree, options: AddRemoteOptions): void;

package/dist/src/generators/setup-mf/lib/add-remote-to-host.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsCommaNeeded = checkIsCommaNeeded;
+exports.addRemoteToHost = addRemoteToHost;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/internal");
+const route_utils_1 = require("../../../utils/nx-devkit/route-utils");
+let tsModule;
+function checkIsCommaNeeded(mfRemoteText) {
+    const remoteText = mfRemoteText.replace(/\s+/g, '');
+    return !remoteText.endsWith(',]')
+        ? remoteText === '[]'
+            ? false
+            : true
+        : false;
+}
+function addRemoteToHost(tree, options) {
+    if (options.host) {
+        const hostProject = (0, devkit_1.readProjectConfiguration)(tree, options.host);
+        const pathToMFManifest = getDynamicManifestFile(tree, hostProject);
+        const hostFederationType = !!pathToMFManifest ? 'dynamic' : 'static';
+        const isHostUsingTypescriptConfig = tree.exists((0, devkit_1.joinPathFragments)(hostProject.root, 'module-federation.config.ts'));
+        if (hostFederationType === 'static') {
+            addRemoteToStaticHost(tree, options, hostProject, isHostUsingTypescriptConfig);
+        }
+        else if (hostFederationType === 'dynamic') {
+            addRemoteToDynamicHost(tree, options, pathToMFManifest, (0, internal_1.getProjectSourceRoot)(hostProject, tree));
+        }
+        addLazyLoadedRouteToHostAppModule(tree, options, hostFederationType);
+    }
+}
+function getDynamicManifestFile(tree, project) {
+    // {sourceRoot}/assets/module-federation.manifest.json was the generated
+    // path for the manifest file in the past. We now generate the manifest
+    // file at {root}/public/module-federation.manifest.json. This check
+    // ensures that we can still support the old path for backwards
+    // compatibility since old projects may still have the manifest file
+    // at the old path.
+    return [
+        (0, devkit_1.joinPathFragments)(project.root, 'public/module-federation.manifest.json'),
+        (0, devkit_1.joinPathFragments)((0, internal_1.getProjectSourceRoot)(project, tree), 'assets/module-federation.manifest.json'),
+    ].find((path) => tree.exists(path));
+}
+function addRemoteToStaticHost(tree, options, hostProject, isHostUsingTypescript) {
+    const hostMFConfigPath = (0, devkit_1.joinPathFragments)(hostProject.root, isHostUsingTypescript
+        ? 'module-federation.config.ts'
+        : 'module-federation.config.js');
+    if (!hostMFConfigPath || !tree.exists(hostMFConfigPath)) {
+        throw new Error(`The selected host application, ${options.host}, does not contain a module-federation.config.{ts,js} or module-federation.manifest.json file. Are you sure it has been set up as a host application?`);
+    }
+    const hostMFConfig = tree.read(hostMFConfigPath, 'utf-8');
+    const { ast, query } = require('@phenomnomnominal/tsquery');
+    const webpackAst = ast(hostMFConfig);
+    const mfRemotesNode = query(webpackAst, 'ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=remotes]) > ArrayLiteralExpression')[0];
+    const endOfPropertiesPos = mfRemotesNode.getEnd() - 1;
+    const isCommaNeeded = checkIsCommaNeeded(mfRemotesNode.getText());
+    const updatedConfig = `${hostMFConfig.slice(0, endOfPropertiesPos)}${isCommaNeeded ? ',' : ''}'${options.appName}',${hostMFConfig.slice(endOfPropertiesPos)}`;
+    tree.write(hostMFConfigPath, updatedConfig);
+}
+function addRemoteToDynamicHost(tree, options, pathToMfManifest, hostSourceRoot) {
+    // TODO(Colum): Remove for Nx 22
+    const usingLegacyDynamicFederation = tree
+        .read(`${hostSourceRoot}/main.ts`, 'utf-8')
+        .includes('setRemoteDefinitions(');
+    (0, devkit_1.updateJson)(tree, pathToMfManifest, (manifest) => {
+        return {
+            ...manifest,
+            [options.appName]: `http://localhost:${options.port}${usingLegacyDynamicFederation ? '' : '/mf-manifest.json'}`,
+        };
+    });
+}
+function addLazyLoadedRouteToHostAppModule(tree, options, hostFederationType) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const hostAppConfig = (0, devkit_1.readProjectConfiguration)(tree, options.host);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(hostAppConfig, tree);
+    const pathToHostRootRouting = `${sourceRoot}/app/app.routes.ts`;
+    if (!tree.exists(pathToHostRootRouting)) {
+        return;
+    }
+    const hostRootRoutingFile = tree.read(pathToHostRootRouting, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(pathToHostRootRouting, hostRootRoutingFile, tsModule.ScriptTarget.Latest, true);
+    // TODO(Colum): Remove for Nx 22
+    const usingLegacyDynamicFederation = hostFederationType === 'dynamic' &&
+        tree
+            .read(`${sourceRoot}/main.ts`, 'utf-8')
+            .includes('setRemoteDefinitions(');
+    if (hostFederationType === 'dynamic') {
+        sourceFile = (0, js_1.insertImport)(tree, sourceFile, pathToHostRootRouting, usingLegacyDynamicFederation ? 'loadRemoteModule' : 'loadRemote', usingLegacyDynamicFederation
+            ? '@nx/angular/mf'
+            : '@module-federation/enhanced/runtime');
+    }
+    const routePathName = options.standalone ? 'Routes' : 'Module';
+    const exportedRemote = options.standalone
+        ? 'remoteRoutes'
+        : 'RemoteEntryModule';
+    const remoteModulePath = `${options.appName.replace(/-/g, '_')}/${routePathName}`;
+    const routeToAdd = hostFederationType === 'dynamic'
+        ? usingLegacyDynamicFederation
+            ? `loadRemoteModule('${options.appName.replace(/-/g, '_')}', './${routePathName}')`
+            : `loadRemote<typeof import('${remoteModulePath}')>('${remoteModulePath}')`
+        : `import('${remoteModulePath}')`;
+    (0, route_utils_1.addRoute)(tree, pathToHostRootRouting, `{
+    path: '${options.appName}',
+    loadChildren: () => ${routeToAdd}.then(m => m!.${exportedRemote})
+    }`);
+    let pathToAppComponentTemplate = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.component.html');
+    const candidatePaths = [
+        pathToAppComponentTemplate,
+        (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.html'),
+    ];
+    for (const path of candidatePaths) {
+        if (tree.exists(path)) {
+            pathToAppComponentTemplate = path;
+            break;
+        }
+    }
+    const appComponent = tree.read(pathToAppComponentTemplate, 'utf-8');
+    if (appComponent.includes(`<ul class="remote-menu">`) &&
+        appComponent.includes('</ul>')) {
+        const indexOfClosingMenuTag = appComponent.indexOf('</ul>');
+        const newAppComponent = `${appComponent.slice(0, indexOfClosingMenuTag)}<li><a routerLink="${options.appName}">${(0, devkit_1.names)(options.appName).className}</a></li>\n${appComponent.slice(indexOfClosingMenuTag)}`;
+        tree.write(pathToAppComponentTemplate, newAppComponent);
+    }
+}

package/dist/src/generators/setup-mf/lib/change-build-target.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function changeBuildTarget(host: Tree, options: Schema): void;

package/dist/src/generators/setup-mf/lib/change-build-target.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeBuildTarget = changeBuildTarget;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+function changeBuildTarget(host, options) {
+    const appConfig = (0, devkit_1.readProjectConfiguration)(host, options.appName);
+    const configExtName = options.typescriptConfiguration ? 'ts' : 'js';
+    appConfig.targets.build.executor = '@nx/angular:webpack-browser';
+    appConfig.targets.build.options = {
+        ...appConfig.targets.build.options,
+        customWebpackConfig: {
+            path: `${appConfig.root}/webpack.config.${configExtName}`,
+        },
+    };
+    appConfig.targets.build.configurations.production = {
+        ...appConfig.targets.build.configurations.production,
+        customWebpackConfig: {
+            path: `${appConfig.root}/webpack.prod.config.${configExtName}`,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(host, options.appName, appConfig);
+    (0, internal_1.addBuildTargetDefaults)(host, '@nx/angular:webpack-browser');
+}

package/dist/src/generators/setup-mf/lib/fix-bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function fixBootstrap(tree: Tree, appRoot: string, options: NormalizedOptions): void;

package/dist/src/generators/setup-mf/lib/generate-config.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function generateWebpackConfig(tree: Tree, options: NormalizedOptions, appRoot: string, remotesWithPorts: {
+    remoteName: string;
+    port: number;
+}[]): void;

package/dist/src/generators/setup-mf/lib/get-remotes-with-ports.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function getRemotesWithPorts(host: Tree, options: Schema): {
+    remoteName: string;
+    port: number;
+}[];

package/dist/src/generators/setup-mf/lib/index.d.ts

@@ -0,0 +1,15 @@
+export * from './add-cypress-workaround';
+export * from './add-remote-entry';
+export * from './add-remote-to-host';
+export * from './change-build-target';
+export * from './fix-bootstrap';
+export * from './generate-config';
+export * from './get-remotes-with-ports';
+export * from './move-angular-plugin-to-dependencies';
+export * from './normalize-options';
+export * from './update-tsconfig';
+export * from './setup-host-if-dynamic';
+export * from './setup-serve-target';
+export * from './update-host-app-routes';
+export * from './remove-dead-code-from-remote';
+export * from './setup-tspath-for-remote';

package/dist/src/generators/setup-mf/lib/move-angular-plugin-to-dependencies.d.ts

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

package/dist/src/generators/setup-mf/lib/normalize-options.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedOptions, Schema } from '../schema';
+export declare function normalizeOptions(tree: Tree, options: Schema): NormalizedOptions;

package/dist/src/generators/setup-mf/lib/remove-dead-code-from-remote.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function removeDeadCodeFromRemote(tree: Tree, options: NormalizedOptions): void;

package/dist/src/generators/setup-mf/lib/remove-dead-code-from-remote.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDeadCodeFromRemote = removeDeadCodeFromRemote;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+function removeDeadCodeFromRemote(tree, options) {
+    const projectName = options.appName;
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+    const { appComponentInfo, nxWelcomeComponentInfo, entryModuleFileName } = options;
+    ['css', 'less', 'scss', 'sass'].forEach((style) => {
+        const pathToComponentStyle = (0, devkit_1.joinPathFragments)(sourceRoot, `app/${appComponentInfo.extensionlessFileName}.${style}`);
+        if (tree.exists(pathToComponentStyle)) {
+            tree.delete(pathToComponentStyle);
+        }
+    });
+    tree.rename(nxWelcomeComponentInfo.path, (0, devkit_1.joinPathFragments)(sourceRoot, `app/remote-entry/${nxWelcomeComponentInfo.fileName}`));
+    tree.delete((0, devkit_1.joinPathFragments)(sourceRoot, `app/${appComponentInfo.extensionlessFileName}.spec.ts`));
+    tree.delete((0, devkit_1.joinPathFragments)(sourceRoot, `app/${appComponentInfo.extensionlessFileName}.html`));
+    if (!options.standalone) {
+        const componentContents = tree.read(appComponentInfo.path, 'utf-8');
+        const isInlineTemplate = !componentContents.includes('templateUrl');
+        const component = componentContents.split(isInlineTemplate ? 'template' : 'templateUrl')[0] +
+            `template: '<router-outlet></router-outlet>'
+
+})
+export class ${appComponentInfo.symbolName} {}`;
+        tree.write(appComponentInfo.path, component);
+        let modulePath = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.module.ts');
+        if (!tree.exists(modulePath)) {
+            modulePath = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app-module.ts');
+        }
+        tree.write(modulePath, `import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { RouterModule } from '@angular/router';
+import { ${appComponentInfo.symbolName} } from './${appComponentInfo.extensionlessFileName}';
+
+@NgModule({
+  declarations: [${appComponentInfo.symbolName}],
+  imports: [
+    BrowserModule,
+    RouterModule.forRoot([{
+      path: '',
+      loadChildren: () => import('./remote-entry/${entryModuleFileName}').then(m => m.RemoteEntryModule)
+    }], { initialNavigation: 'enabledBlocking' }),
+  ],
+  providers: [],
+  bootstrap: [${appComponentInfo.symbolName}],
+})
+export class AppModule {}`);
+    }
+    else {
+        tree.delete(appComponentInfo.path);
+        const pathToIndexHtml = project.targets.build.options.index;
+        const indexContents = tree.read(pathToIndexHtml, 'utf-8');
+        const rootSelectorRegex = new RegExp(`${options.prefix || 'app'}-root`, 'ig');
+        const remoteEntrySelector = `${options.prefix || 'app'}-${projectName}-entry`;
+        const newIndexContents = indexContents.replace(rootSelectorRegex, remoteEntrySelector);
+        tree.write(pathToIndexHtml, newIndexContents);
+    }
+}

package/dist/src/generators/setup-mf/lib/setup-host-if-dynamic.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function setupHostIfDynamic(tree: Tree, options: Schema): void;

package/dist/src/generators/setup-mf/lib/setup-serve-target.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function setupServeTarget(host: Tree, options: Schema): void;

package/dist/src/generators/setup-mf/lib/setup-tspath-for-remote.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function setupTspathForRemote(tree: Tree, options: NormalizedOptions): void;

package/dist/src/generators/setup-mf/lib/update-host-app-routes.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function updateHostAppRoutes(tree: Tree, options: NormalizedOptions): void;

package/dist/src/generators/setup-mf/lib/update-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function updateTsConfig(tree: Tree, options: NormalizedOptions): void;

package/dist/src/generators/setup-mf/setup-mf.d.ts

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function setupMf(tree: Tree, rawOptions: Schema): Promise<GeneratorCallback>;
+export default setupMf;

package/dist/src/generators/setup-mf/setup-mf.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMf = setupMf;
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const versions_1 = require("../../utils/versions");
+const version_utils_1 = require("../utils/version-utils");
+const lib_1 = require("./lib");
+async function setupMf(tree, rawOptions) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.appName);
+    const tasks = [];
+    if (options.mfType === 'remote') {
+        (0, lib_1.addRemoteToHost)(tree, {
+            appName: options.appName,
+            host: options.host,
+            standalone: options.standalone,
+            port: options.port,
+        });
+        (0, lib_1.addRemoteEntry)(tree, options, projectConfig.root);
+        (0, lib_1.removeDeadCodeFromRemote)(tree, options);
+        (0, lib_1.setupTspathForRemote)(tree, options);
+        if (!options.skipPackageJson) {
+            tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {
+                '@module-federation/enhanced': versions_1.moduleFederationEnhancedVersion,
+            }, {
+                '@nx/web': versions_1.nxVersion,
+                '@nx/webpack': versions_1.nxVersion,
+                '@nx/module-federation': versions_1.nxVersion,
+            }));
+        }
+    }
+    const remotesWithPorts = (0, lib_1.getRemotesWithPorts)(tree, options);
+    (0, lib_1.generateWebpackConfig)(tree, options, projectConfig.root, remotesWithPorts);
+    (0, lib_1.changeBuildTarget)(tree, options);
+    (0, lib_1.updateTsConfig)(tree, options);
+    (0, lib_1.setupServeTarget)(tree, options);
+    if (options.mfType === 'host') {
+        (0, lib_1.setupHostIfDynamic)(tree, options);
+        (0, lib_1.updateHostAppRoutes)(tree, options);
+        for (const { remoteName, port } of remotesWithPorts) {
+            (0, lib_1.addRemoteToHost)(tree, {
+                appName: remoteName,
+                host: options.appName,
+                standalone: options.standalone,
+                port,
+            });
+        }
+        if (!options.skipPackageJson) {
+            tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+                '@nx/webpack': versions_1.nxVersion,
+                '@module-federation/enhanced': versions_1.moduleFederationEnhancedVersion,
+                '@nx/module-federation': versions_1.nxVersion,
+            }));
+        }
+    }
+    (0, lib_1.fixBootstrap)(tree, projectConfig.root, options);
+    if (options.mfType === 'host' || options.federationType === 'dynamic') {
+        /**
+         * Host applications and dynamic federation applications generate runtime
+         * code that depends on the @nx/angular plugin. Ensure that the plugin is
+         * in the production dependencies.
+         */
+        (0, lib_1.moveAngularPluginToDependencies)(tree);
+    }
+    if (!options.skipE2E) {
+        (0, lib_1.addCypressOnErrorWorkaround)(tree, options);
+    }
+    if (!options.skipPackageJson && options.typescriptConfiguration) {
+        // Angular custom-webpack loads webpack.config.ts at build time. Node native
+        // TS strip can't resolve the extensionless `./module-federation.config`
+        // import under strict ESM, so loadTsFile needs ts-node as the fallback.
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'ts-node': versions_1.tsNodeVersion }, undefined, true));
+    }
+    if (!options.skipPackageJson) {
+        const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+        if (angularMajorVersion >= 20) {
+            const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ??
+                (0, version_utils_1.versions)(tree).angularDevkitVersion;
+            // the executors used by MF require @angular-devkit/build-angular
+            tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@angular-devkit/build-angular': angularDevkitVersion }, undefined, true));
+        }
+    }
+    // format files
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = setupMf;

package/dist/src/generators/setup-ssr/lib/add-dependencies.d.ts

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

package/dist/src/generators/setup-ssr/lib/add-hydration.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedGeneratorOptions } from '../schema';
+export declare function addHydration(tree: Tree, options: NormalizedGeneratorOptions): void;

package/dist/src/generators/setup-ssr/lib/add-hydration.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHydration = addHydration;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/internal");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+let tsModule;
+let tsquery;
+function addHydration(tree, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(projectConfig, tree);
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+        tsquery = require('@phenomnomnominal/tsquery').tsquery;
+    }
+    let pathToClientConfigFile;
+    if (options.standalone) {
+        pathToClientConfigFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.config.ts');
+    }
+    else {
+        pathToClientConfigFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.module.ts');
+        if (!tree.exists(pathToClientConfigFile)) {
+            pathToClientConfigFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app-module.ts');
+        }
+    }
+    const sourceText = tree.read(pathToClientConfigFile, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(pathToClientConfigFile, sourceText, tsModule.ScriptTarget.Latest, true);
+    const provideClientHydrationCallExpression = tsquery(sourceFile, 'ObjectLiteralExpression PropertyAssignment:has(Identifier[name=providers]) ArrayLiteralExpression CallExpression:has(Identifier[name=provideClientHydration])')[0];
+    if (provideClientHydrationCallExpression) {
+        return;
+    }
+    const addImport = (source, symbolName, packageName, filePath, isDefault = false) => {
+        return (0, js_1.insertImport)(tree, source, filePath, symbolName, packageName, isDefault);
+    };
+    sourceFile = addImport(sourceFile, 'provideClientHydration', '@angular/platform-browser', pathToClientConfigFile);
+    sourceFile = addImport(sourceFile, 'withEventReplay', '@angular/platform-browser', pathToClientConfigFile);
+    const provider = 'provideClientHydration(withEventReplay())';
+    if (options.standalone) {
+        (0, ast_utils_1.addProviderToAppConfig)(tree, pathToClientConfigFile, provider);
+    }
+    else {
+        (0, ast_utils_1.addProviderToModule)(tree, sourceFile, pathToClientConfigFile, provider);
+    }
+}

package/dist/src/generators/setup-ssr/lib/add-server-file.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedGeneratorOptions } from '../schema';
+export declare function addServerFile(tree: Tree, options: NormalizedGeneratorOptions): void;

package/dist/src/generators/setup-ssr/lib/add-server-file.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addServerFile = addServerFile;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const path_1 = require("path");
+const zoneless_1 = require("../../../utils/zoneless");
+const version_utils_1 = require("../../utils/version-utils");
+const constants_1 = require("./constants");
+function addServerFile(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const { outputPath } = project.targets.build.options;
+    const browserDistDirectory = options.isUsingApplicationBuilder
+        ? getApplicationBuilderBrowserOutputPath(outputPath)
+        : outputPath;
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const baseFilesPath = (0, path_1.join)(__dirname, '..', 'files');
+    let pathToFiles;
+    if (angularMajorVersion >= 20) {
+        pathToFiles = (0, path_1.join)(baseFilesPath, 'v20+', options.isUsingApplicationBuilder
+            ? 'application-builder'
+            : 'server-builder', 'server');
+    }
+    else {
+        pathToFiles = (0, path_1.join)(baseFilesPath, 'v19', options.isUsingApplicationBuilder
+            ? 'application-builder' +
+                (options.serverRouting ? '' : '-common-engine')
+            : 'server-builder', 'server');
+    }
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+    const zoneless = (0, zoneless_1.isZonelessApp)(project);
+    (0, devkit_1.generateFiles)(tree, pathToFiles, sourceRoot, {
+        ...options,
+        browserDistDirectory,
+        zoneless,
+        useDefaultImport: angularMajorVersion >= 21,
+        angularMajorVersion,
+        tpl: '',
+    });
+}
+function getApplicationBuilderBrowserOutputPath(outputPath) {
+    if (outputPath) {
+        if (typeof outputPath === 'string') {
+            // when `outputPath` is a string, it's the base path, so we return the default browser path
+            return constants_1.DEFAULT_BROWSER_DIR;
+        }
+        return outputPath.browser ?? constants_1.DEFAULT_BROWSER_DIR;
+    }
+    return constants_1.DEFAULT_BROWSER_DIR;
+}