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

package/src/generators/setup-mf/lib/update-host-app-routes.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateHostAppRoutes = void 0;
+const project_configuration_1 = require("nx/src/generators/utils/project-configuration");
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const route_utils_1 = require("../../../utils/nx-devkit/route-utils");
+let tsModule;
+function updateHostAppRoutes(tree, options) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const { sourceRoot } = (0, project_configuration_1.readProjectConfiguration)(tree, options.appName);
+    const remoteRoutes = options.remotes && Array.isArray(options.remotes)
+        ? options.remotes.reduce((routes, remote) => `${routes}\n<li><a routerLink='${remote}'>${(0, devkit_1.names)(remote).className}</a></li>`, '')
+        : '';
+    tree.write((0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.component.html'), `<ul class="remote-menu">
+<li><a routerLink="/">Home</a></li>${remoteRoutes}
+</ul>
+<router-outlet></router-outlet>
+`);
+    let pathToHostRootRoutingFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.routes.ts');
+    let hostRootRoutingFile = tree.read(pathToHostRootRoutingFile, 'utf-8');
+    if (!hostRootRoutingFile) {
+        pathToHostRootRoutingFile = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app-routing.module.ts');
+        hostRootRoutingFile = tree.read(pathToHostRootRoutingFile, 'utf-8');
+    }
+    let sourceFile = tsModule.createSourceFile(pathToHostRootRoutingFile, hostRootRoutingFile, tsModule.ScriptTarget.Latest, true);
+    (0, route_utils_1.addRoute)(tree, pathToHostRootRoutingFile, `{
+      path: '',
+      component: NxWelcomeComponent
+    }`);
+    tree.write(pathToHostRootRoutingFile, `import { NxWelcomeComponent } from './nx-welcome.component';
+${tree.read(pathToHostRootRoutingFile, 'utf-8')}`);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/host-files'), (0, devkit_1.joinPathFragments)(sourceRoot, 'app'), {
+        appName: options.appName,
+        standalone: options.standalone,
+        tmpl: '',
+    });
+}
+exports.updateHostAppRoutes = updateHostAppRoutes;

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

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

package/src/generators/setup-mf/lib/update-tsconfig.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateTsConfig(tree, schema) {
+    const { root } = (0, devkit_1.readProjectConfiguration)(tree, schema.appName);
+    (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(root, `tsconfig.app.json`), (json) => {
+        json.compilerOptions ??= {};
+        json.compilerOptions.target = 'ES2020';
+        if (schema.mfType === 'remote') {
+            json.files ??= [];
+            json.files.push(schema.standalone
+                ? 'src/app/remote-entry/entry.routes.ts'
+                : 'src/app/remote-entry/entry.module.ts');
+        }
+        return json;
+    });
+}
+exports.updateTsConfig = updateTsConfig;

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

@@ -0,0 +1,24 @@
+type FederationType = 'static' | 'dynamic';
+
+export interface Schema {
+  appName: string;
+  mfType: 'host' | 'remote';
+  port?: number;
+  remotes?: string[];
+  host?: string;
+  federationType?: FederationType;
+  routing?: boolean;
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  e2eProjectName?: string;
+  prefix?: string;
+  standalone?: boolean;
+  skipE2E?: boolean;
+  typescriptConfiguration?: boolean;
+  setParserOptionsProject?: boolean;
+}
+
+export interface NormalizedOptions extends Schema {
+  federationType: FederationType;
+  prefix: string | undefined;
+}

package/src/generators/setup-mf/schema.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "GeneratorAngularMFSetup",
+  "cli": "nx",
+  "title": "Generate Module Federation Setup for Angular App",
+  "description": "Create Module Federation configuration files for given Angular Application.",
+  "type": "object",
+  "properties": {
+    "appName": {
+      "type": "string",
+      "description": "The name of the application to generate the Module Federation configuration for.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What app would you like to generate a Module Federation configuration for?",
+      "x-dropdown": "projects"
+    },
+    "mfType": {
+      "type": "string",
+      "enum": ["host", "remote"],
+      "description": "Type of application to generate the Module Federation configuration for.",
+      "default": "remote"
+    },
+    "federationType": {
+      "type": "string",
+      "enum": ["static", "dynamic"],
+      "description": "Use either Static or Dynamic Module Federation pattern for the application.",
+      "default": "static"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port at which the remote application should be served."
+    },
+    "remotes": {
+      "type": "array",
+      "description": "A list of remote application names that the host application should consume."
+    },
+    "host": {
+      "type": "string",
+      "description": "The name of the host application that the remote application will be consumed by."
+    },
+    "routing": {
+      "type": "boolean",
+      "description": "Generate a routing setup to allow a host application to route to the remote application.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting the workspace after the generator completes.",
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "skipE2E": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not set up E2E related config."
+    },
+    "e2eProjectName": {
+      "type": "string",
+      "description": "The project name of the associated E2E project for the application. This is only required for Cypress E2E projects that do not follow the naming convention `<appName>-e2e`."
+    },
+    "prefix": {
+      "type": "string",
+      "description": "The prefix to use for any generated component."
+    },
+    "standalone": {
+      "type": "boolean",
+      "description": "Whether the application is a standalone application.",
+      "default": true
+    },
+    "typescriptConfiguration": {
+      "type": "boolean",
+      "description": "Whether the module federation configuration and webpack configuration files should use TS.",
+      "default": true
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    }
+  },
+  "required": ["appName", "mfType"],
+  "additionalProperties": false,
+  "examplesFile": "../../../docs/setup-mf-examples.md"
+}

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMf = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+const versions_1 = require("../../utils/versions");
+async function setupMf(tree, rawOptions) {
+    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.appName);
+    let installTask = () => { };
+    if (options.mfType === 'remote') {
+        (0, lib_1.addRemoteToHost)(tree, options);
+        (0, lib_1.addRemoteEntry)(tree, options, projectConfig.root);
+        (0, lib_1.removeDeadCodeFromRemote)(tree, options);
+        (0, lib_1.setupTspathForRemote)(tree, options);
+        installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/web': versions_1.nxVersion, '@nx/webpack': 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);
+    (0, lib_1.fixBootstrap)(tree, projectConfig.root, options);
+    if (options.mfType === 'host') {
+        (0, lib_1.setupHostIfDynamic)(tree, options);
+        (0, lib_1.updateHostAppRoutes)(tree, options);
+        installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/webpack': versions_1.nxVersion });
+    }
+    if (!options.skipE2E) {
+        (0, lib_1.addCypressOnErrorWorkaround)(tree, options);
+    }
+    // format files
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.setupMf = setupMf;
+exports.default = setupMf;

package/src/generators/setup-ssr/files/ngmodule/base/src/__main__

@@ -0,0 +1 @@
+export { <%= rootModuleClassName %> as default } from './app/<%= rootModuleFileName.slice(0, -3) %>';

package/src/generators/setup-ssr/files/ngmodule/base/src/app/__rootModuleFileName__

@@ -0,0 +1,14 @@
+import { NgModule } from '@angular/core';
+import { ServerModule } from '@angular/platform-server';
+
+import { AppModule } from './app.module';
+import { AppComponent } from './app.component';
+
+@NgModule({
+  imports: [
+    AppModule,
+    ServerModule,
+  ],
+  bootstrap: [AppComponent],
+})
+export class <%= rootModuleClassName %> {}

package/src/generators/setup-ssr/files/ngmodule/pre-v15-2/src/main.ts__tpl__

@@ -0,0 +1,14 @@
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+import { AppModule } from './app/app.module';
+
+function bootstrap() {
+  platformBrowserDynamic()
+    .bootstrapModule(AppModule)
+    .catch((err) => console.error(err));
+}
+
+if (document.readyState !== 'loading') {
+  bootstrap();
+} else {
+  document.addEventListener('DOMContentLoaded', bootstrap);
+}

package/src/generators/setup-ssr/files/root/tsconfig.server.json__tpl__

@@ -0,0 +1,15 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.app.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/server",
+    "target": "es2019",
+    "types": [
+      "node"
+    ]
+  },
+  "files": [
+    "src/<%= main %>",
+    "server.ts",
+  ]
+}

package/src/generators/setup-ssr/files/server/application-builder/__serverFileName__

@@ -0,0 +1,56 @@
+import { APP_BASE_HREF } from '@angular/common';
+import { CommonEngine } from '@angular/ssr';
+import express from 'express';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import <% if (standalone) { %>bootstrap<% } else { %><%= rootModuleClassName %><% } %> from './src/<%= main.slice(0, -3) %>';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const serverDistFolder = dirname(fileURLToPath(import.meta.url));
+  const browserDistFolder = resolve(serverDistFolder, '../<%= browserBundleOutputPath %>');
+  const indexHtml = join(serverDistFolder, 'index.server.html');
+
+  const commonEngine = new CommonEngine();
+
+  server.set('view engine', 'html');
+  server.set('views', browserDistFolder);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get('*.*', express.static(browserDistFolder, {
+    maxAge: '1y'
+  }));
+
+  // All regular routes use the Angular engine
+  server.get('*', (req, res, next) => {
+    const { protocol, originalUrl, baseUrl, headers } = req;
+
+    commonEngine
+      .render({
+        bootstrap<% if (!standalone) { %>: <%= rootModuleClassName %><% } %>,
+        documentFilePath: indexHtml,
+        url: `${protocol}://${headers.host}${originalUrl}`,
+        publicPath: browserDistFolder,
+        providers: [{ provide: APP_BASE_HREF, useValue: baseUrl }],
+      })
+      .then((html) => res.send(html))
+      .catch((err) => next(err));
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || <%= serverPort %>;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+  });
+}
+
+run();

package/src/generators/setup-ssr/files/server/server-builder/pre-v17/__serverFileName__

@@ -0,0 +1,59 @@
+import 'zone.js/dist/zone-node';
+
+import { APP_BASE_HREF } from '@angular/common';
+import { ngExpressEngine } from '@nguniversal/express-engine';
+import * as express from 'express';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import <% if (standalone) { %>bootstrap<% } else { %><%= rootModuleClassName %><% } %> from './src/<%= main.slice(0, -3) %>';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const distFolder = join(process.cwd(), '<%= browserBundleOutputPath %>');
+  const indexHtml = existsSync(join(distFolder, 'index.original.html')) ? 'index.original.html' : 'index';
+
+  // Our Universal express-engine (found @ https://github.com/angular/universal/tree/main/modules/express-engine)
+  server.engine('html', ngExpressEngine({
+    bootstrap<% if (!standalone) { %>: <%= rootModuleClassName %><% } %>,
+  }));
+
+  server.set('view engine', 'html');
+  server.set('views', distFolder);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get('*.*', express.static(distFolder, {
+    maxAge: '1y'
+  }));
+
+  // All regular routes use the Universal engine
+  server.get('*', (req, res) => {
+    res.render(indexHtml, { req, providers: [{ provide: APP_BASE_HREF, useValue: req.baseUrl }] });
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || <%= serverPort %>;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+  });
+}
+
+// Webpack will replace 'require' with '__webpack_require__'
+// '__non_webpack_require__' is a proxy to Node 'require'
+// The below code is to ensure that the server is run only when not requiring the bundle.
+declare const __non_webpack_require__: NodeRequire;
+const mainModule = __non_webpack_require__.main;
+const moduleFilename = mainModule && mainModule.filename || '';
+if (moduleFilename === __filename || moduleFilename.includes('iisnode')) {
+  run();
+}
+
+export <% if (standalone) { %>default bootstrap<% } else { %>* from './src/<%= main.slice(0, -3) %>'<% } %>;

package/src/generators/setup-ssr/files/server/server-builder/v17+/__serverFileName__

@@ -0,0 +1,69 @@
+import 'zone.js/node';
+
+import { APP_BASE_HREF } from '@angular/common';
+import { CommonEngine } from '@angular/ssr';
+import * as express from 'express';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import <% if (standalone) { %>bootstrap<% } else { %><%= rootModuleClassName %><% } %> from './src/<%= main.slice(0, -3) %>';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const distFolder = join(process.cwd(), '<%= browserBundleOutputPath %>');
+  const indexHtml = existsSync(join(distFolder, 'index.original.html'))
+    ? join(distFolder, 'index.original.html')
+    : join(distFolder, 'index.html');
+
+  const commonEngine = new CommonEngine();
+
+  server.set('view engine', 'html');
+  server.set('views', distFolder);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get('*.*', express.static(distFolder, {
+    maxAge: '1y'
+  }));
+
+  // All regular routes use the Angular engine
+  server.get('*', (req, res, next) => {
+    const { protocol, originalUrl, baseUrl, headers } = req;
+
+    commonEngine
+      .render({
+        bootstrap<% if (!standalone) { %>: <%= rootModuleClassName %><% } %>,
+        documentFilePath: indexHtml,
+        url: `${protocol}://${headers.host}${originalUrl}`,
+        publicPath: distFolder,
+        providers: [{ provide: APP_BASE_HREF, useValue: baseUrl }],
+      })
+      .then((html) => res.send(html))
+      .catch((err) => next(err));
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || <%= serverPort %>;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+  });
+}
+
+// Webpack will replace 'require' with '__webpack_require__'
+// '__non_webpack_require__' is a proxy to Node 'require'
+// The below code is to ensure that the server is run only when not requiring the bundle.
+declare const __non_webpack_require__: NodeRequire;
+const mainModule = __non_webpack_require__.main;
+const moduleFilename = mainModule && mainModule.filename || '';
+if (moduleFilename === __filename || moduleFilename.includes('iisnode')) {
+  run();
+}
+
+export default <% if (standalone) { %>bootstrap<% } else { %><%= rootModuleClassName %><% } %>;

package/src/generators/setup-ssr/files/standalone/src/__main__

@@ -0,0 +1,7 @@
+import { bootstrapApplication } from '@angular/platform-browser';
+import { AppComponent } from './app/app.component';
+import { config } from './app/app.config.server';
+
+const bootstrap = () => bootstrapApplication(AppComponent, config);
+
+export default bootstrap;

package/src/generators/setup-ssr/files/standalone/src/app/app.config.server.ts__tpl__

@@ -0,0 +1,11 @@
+import { mergeApplicationConfig, ApplicationConfig } from '@angular/core';
+import { provideServerRendering } from '@angular/platform-server';
+import { appConfig } from './app.config';
+
+const serverConfig: ApplicationConfig = {
+  providers: [
+    provideServerRendering()
+  ]
+};
+
+export const config = mergeApplicationConfig(appConfig, serverConfig);

package/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/src/generators/setup-ssr/lib/add-dependencies.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const version_utils_1 = require("../../utils/version-utils");
+function addDependencies(tree, isUsingApplicationBuilder) {
+    const pkgVersions = (0, version_utils_1.versions)(tree);
+    const { major: angularMajorVersion, version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const dependencies = {
+        '@angular/platform-server': (0, version_utils_1.getInstalledPackageVersionInfo)(tree, '@angular/platform-server')
+            ?.version ?? pkgVersions.angularVersion,
+        express: pkgVersions.expressVersion,
+    };
+    const devDependencies = {
+        '@types/express': pkgVersions.typesExpressVersion,
+    };
+    if (angularMajorVersion >= 17) {
+        dependencies['@angular/ssr'] =
+            (0, version_utils_1.getInstalledPackageVersionInfo)(tree, '@angular-devkit/build-angular')
+                ?.version ?? pkgVersions.angularDevkitVersion;
+        if (!isUsingApplicationBuilder && (0, semver_1.gte)(angularVersion, '17.1.0')) {
+            devDependencies['browser-sync'] = pkgVersions.browserSyncVersion;
+        }
+    }
+    else {
+        dependencies['@nguniversal/express-engine'] =
+            (0, version_utils_1.getInstalledPackageVersionInfo)(tree, '@nguniversal/express-engine')
+                ?.version ?? pkgVersions.ngUniversalVersion;
+        devDependencies['@nguniversal/builders'] =
+            (0, version_utils_1.getInstalledPackageVersionInfo)(tree, '@nguniversal/builders')?.version ??
+                pkgVersions.ngUniversalVersion;
+    }
+    (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDependencies);
+}
+exports.addDependencies = addDependencies;

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

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

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHydration = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+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);
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        tsquery = require('@phenomnomnominal/tsquery').tsquery;
+    }
+    const pathToClientConfigFile = options.standalone
+        ? (0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'app/app.config.ts')
+        : (0, devkit_1.joinPathFragments)(projectConfig.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);
+    if (options.standalone) {
+        (0, ast_utils_1.addProviderToAppConfig)(tree, pathToClientConfigFile, 'provideClientHydration()');
+    }
+    else {
+        (0, ast_utils_1.addProviderToModule)(tree, sourceFile, pathToClientConfigFile, 'provideClientHydration()');
+    }
+}
+exports.addHydration = addHydration;

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addServerFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../utils/version-utils");
+const constants_1 = require("./constants");
+function addServerFile(tree, schema, isUsingApplicationBuilder) {
+    const { root: projectRoot, targets } = (0, devkit_1.readProjectConfiguration)(tree, schema.project);
+    const { outputPath } = targets.build.options;
+    const browserBundleOutputPath = isUsingApplicationBuilder
+        ? getApplicationBuilderBrowserOutputPath(outputPath)
+        : outputPath;
+    const pathToFiles = (0, devkit_1.joinPathFragments)(__dirname, '..', 'files');
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(pathToFiles, 'server', ...(isUsingApplicationBuilder
+        ? ['application-builder']
+        : angularMajorVersion >= 17
+            ? ['server-builder', 'v17+']
+            : ['server-builder', 'pre-v17'])), projectRoot, { ...schema, browserBundleOutputPath, tpl: '' });
+}
+exports.addServerFile = addServerFile;
+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;
+}

package/src/generators/setup-ssr/lib/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_BROWSER_DIR = "browser";
+export declare const DEFAULT_MEDIA_DIR = "media";
+export declare const DEFAULT_SERVER_DIR = "server";

package/src/generators/setup-ssr/lib/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SERVER_DIR = exports.DEFAULT_MEDIA_DIR = exports.DEFAULT_BROWSER_DIR = void 0;
+exports.DEFAULT_BROWSER_DIR = 'browser';
+exports.DEFAULT_MEDIA_DIR = 'media';
+exports.DEFAULT_SERVER_DIR = 'server';

package/src/generators/setup-ssr/lib/generate-files.d.ts

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

package/src/generators/setup-ssr/lib/generate-files.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSSRFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const version_utils_1 = require("../../utils/version-utils");
+function generateSSRFiles(tree, schema, isUsingApplicationBuilder) {
+    const { root: projectRoot, targets } = (0, devkit_1.readProjectConfiguration)(tree, schema.project);
+    if (targets.server ||
+        (isUsingApplicationBuilder && targets.build.options?.server !== undefined)) {
+        // server has already been added
+        return;
+    }
+    const pathToFiles = (0, devkit_1.joinPathFragments)(__dirname, '..', 'files');
+    const { version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    if (schema.standalone) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(pathToFiles, 'standalone'), projectRoot, { ...schema, tpl: '' });
+    }
+    else {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(pathToFiles, 'ngmodule', 'base'), projectRoot, { ...schema, tpl: '' });
+        if ((0, semver_1.lt)(angularVersion, '15.2.0')) {
+            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(pathToFiles, 'ngmodule', 'pre-v15-2'), projectRoot, { ...schema, tpl: '' });
+        }
+    }
+}
+exports.generateSSRFiles = generateSSRFiles;