@angular/build 19.0.0-next.7 → 19.0.0-next.9

package/src/utils/server-rendering/launch-server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+export declare const DEFAULT_URL: import("url").URL;
+/**
+ * Launches a server that handles local requests.
+ *
+ * @returns A promise that resolves to the URL of the running server.
+ */
+export declare function launchServer(): Promise<URL>;

package/src/utils/server-rendering/launch-server.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_URL = void 0;
+exports.launchServer = launchServer;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_http_1 = require("node:http");
+const load_esm_1 = require("../load-esm");
+const load_esm_from_memory_1 = require("./load-esm-from-memory");
+const utils_1 = require("./utils");
+exports.DEFAULT_URL = new URL('http://ng-localhost/');
+/**
+ * Launches a server that handles local requests.
+ *
+ * @returns A promise that resolves to the URL of the running server.
+ */
+async function launchServer() {
+    const { default: handler } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./server.mjs');
+    const { createWebRequestFromNodeRequest, writeResponseToNodeResponse } = await (0, load_esm_1.loadEsmModule)('@angular/ssr/node');
+    if (!(0, utils_1.isSsrNodeRequestHandler)(handler) && !(0, utils_1.isSsrRequestHandler)(handler)) {
+        return exports.DEFAULT_URL;
+    }
+    const server = (0, node_http_1.createServer)((req, res) => {
+        (async () => {
+            // handle request
+            if ((0, utils_1.isSsrNodeRequestHandler)(handler)) {
+                await handler(req, res, (e) => {
+                    throw e;
+                });
+            }
+            else {
+                const webRes = await handler(createWebRequestFromNodeRequest(req));
+                if (webRes) {
+                    await writeResponseToNodeResponse(webRes, res);
+                }
+                else {
+                    res.statusCode = 501;
+                    res.end('Not Implemented.');
+                }
+            }
+        })().catch((e) => {
+            res.statusCode = 500;
+            res.end('Internal Server Error.');
+            // eslint-disable-next-line no-console
+            console.error(e);
+        });
+    });
+    server.unref();
+    await new Promise((resolve) => server.listen(0, 'localhost', resolve));
+    const serverAddress = server.address();
+    (0, node_assert_1.default)(serverAddress, 'Server address should be defined.');
+    (0, node_assert_1.default)(typeof serverAddress !== 'string', 'Server address should not be a string.');
+    return new URL(`http://localhost:${serverAddress.port}/`);
+}

package/src/utils/server-rendering/load-esm-from-memory.d.ts

@@ -15,5 +15,12 @@ interface MainServerBundleExports {
     ɵextractRoutesAndCreateRouteTree: typeof ɵextractRoutesAndCreateRouteTree;
     ɵgetOrCreateAngularServerApp: typeof ɵgetOrCreateAngularServerApp;
 }
+/**
+ * Represents the exports available from the server bundle.
+ */
+interface ServerBundleExports {
+    default: unknown;
+}
 export declare function loadEsmModuleFromMemory(path: './main.server.mjs'): Promise<MainServerBundleExports>;
+export declare function loadEsmModuleFromMemory(path: './server.mjs'): Promise<ServerBundleExports>;
 export {};

package/src/utils/server-rendering/manifest.d.ts

@@ -7,7 +7,9 @@
  */
 import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
 import type { BuildOutputFile } from '../../tools/esbuild/bundler-context';
+import { PrerenderedRoutesRecord } from '../../tools/esbuild/bundler-execution-result';
 export declare const SERVER_APP_MANIFEST_FILENAME = "angular-app-manifest.mjs";
+export declare const SERVER_APP_ENGINE_MANIFEST_FILENAME = "angular-app-engine-manifest.mjs";
 /**
  * Generates the server manifest for the App Engine environment.
  *
@@ -19,9 +21,10 @@ export declare const SERVER_APP_MANIFEST_FILENAME = "angular-app-manifest.mjs";
  * includes settings for inlining locales and determining the output structure.
  * @param baseHref - The base HREF for the application. This is used to set the base URL
  * for all relative URLs in the application.
+ * @param perenderedRoutes - A record mapping static paths to their associated data.
  * @returns A string representing the content of the SSR server manifest for App Engine.
  */
-export declare function generateAngularServerAppEngineManifest(i18nOptions: NormalizedApplicationBuildOptions['i18nOptions'], baseHref: string | undefined): string;
+export declare function generateAngularServerAppEngineManifest(i18nOptions: NormalizedApplicationBuildOptions['i18nOptions'], baseHref: string | undefined, perenderedRoutes?: PrerenderedRoutesRecord | undefined): string;
 /**
  * Generates the server manifest for the standard Node.js environment.
  *
@@ -38,7 +41,10 @@ export declare function generateAngularServerAppEngineManifest(i18nOptions: Norm
  * in the server-side rendered pages.
  * @param routes - An optional array of route definitions for the application, used for
  * server-side rendering and routing.
+ * @param locale - An optional string representing the locale or language code to be used for
+ * the application, helping with localization and rendering content specific to the locale.
+ *
  * @returns A string representing the content of the SSR server manifest for the Node.js
  * environment.
  */
-export declare function generateAngularServerAppManifest(additionalHtmlOutputFiles: Map<string, BuildOutputFile>, outputFiles: BuildOutputFile[], inlineCriticalCss: boolean, routes: readonly unknown[] | undefined): string;
+export declare function generateAngularServerAppManifest(additionalHtmlOutputFiles: Map<string, BuildOutputFile>, outputFiles: BuildOutputFile[], inlineCriticalCss: boolean, routes: readonly unknown[] | undefined, locale: string | undefined): string;

package/src/utils/server-rendering/manifest.js

@@ -7,12 +7,31 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SERVER_APP_MANIFEST_FILENAME = void 0;
+exports.SERVER_APP_ENGINE_MANIFEST_FILENAME = exports.SERVER_APP_MANIFEST_FILENAME = void 0;
 exports.generateAngularServerAppEngineManifest = generateAngularServerAppEngineManifest;
 exports.generateAngularServerAppManifest = generateAngularServerAppManifest;
 const options_1 = require("../../builders/application/options");
 exports.SERVER_APP_MANIFEST_FILENAME = 'angular-app-manifest.mjs';
+exports.SERVER_APP_ENGINE_MANIFEST_FILENAME = 'angular-app-engine-manifest.mjs';
 const MAIN_SERVER_OUTPUT_FILENAME = 'main.server.mjs';
+/**
+ * A mapping of unsafe characters to their escaped Unicode equivalents.
+ */
+const UNSAFE_CHAR_MAP = {
+    '`': '\\`',
+    '$': '\\$',
+    '\\': '\\\\',
+};
+/**
+ * Escapes unsafe characters in a given string by replacing them with
+ * their Unicode escape sequences.
+ *
+ * @param str - The string to be escaped.
+ * @returns The escaped string where unsafe characters are replaced.
+ */
+function escapeUnsafeChars(str) {
+    return str.replace(/[$`\\]/g, (c) => UNSAFE_CHAR_MAP[c]);
+}
 /**
  * Generates the server manifest for the App Engine environment.
  *
@@ -24,26 +43,43 @@ const MAIN_SERVER_OUTPUT_FILENAME = 'main.server.mjs';
  * includes settings for inlining locales and determining the output structure.
  * @param baseHref - The base HREF for the application. This is used to set the base URL
  * for all relative URLs in the application.
+ * @param perenderedRoutes - A record mapping static paths to their associated data.
  * @returns A string representing the content of the SSR server manifest for App Engine.
  */
-function generateAngularServerAppEngineManifest(i18nOptions, baseHref) {
+function generateAngularServerAppEngineManifest(i18nOptions, baseHref, perenderedRoutes = {}) {
     const entryPointsContent = [];
     if (i18nOptions.shouldInline) {
         for (const locale of i18nOptions.inlineLocales) {
             const importPath = './' + (i18nOptions.flatOutput ? '' : locale + '/') + MAIN_SERVER_OUTPUT_FILENAME;
-            const localWithBaseHref = (0, options_1.getLocaleBaseHref)('', i18nOptions, locale) || '/';
-            entryPointsContent.push(`['${localWithBaseHref}', () => import('${importPath}')]`);
+            let localeWithBaseHref = (0, options_1.getLocaleBaseHref)('', i18nOptions, locale) || '/';
+            // Remove leading and trailing slashes.
+            const start = localeWithBaseHref[0] === '/' ? 1 : 0;
+            const end = localeWithBaseHref[localeWithBaseHref.length - 1] === '/' ? -1 : undefined;
+            localeWithBaseHref = localeWithBaseHref.slice(start, end);
+            entryPointsContent.push(`['${localeWithBaseHref}', () => import('${importPath}')]`);
         }
     }
     else {
-        entryPointsContent.push(`['/', () => import('./${MAIN_SERVER_OUTPUT_FILENAME}')]`);
+        entryPointsContent.push(`['', () => import('./${MAIN_SERVER_OUTPUT_FILENAME}')]`);
+    }
+    const staticHeaders = [];
+    for (const [path, { headers }] of Object.entries(perenderedRoutes)) {
+        if (!headers) {
+            continue;
+        }
+        const headersValues = [];
+        for (const [name, value] of Object.entries(headers)) {
+            headersValues.push(`['${name}', '${encodeURIComponent(value)}']`);
+        }
+        staticHeaders.push(`['${path}', [${headersValues.join(', ')}]]`);
     }
     const manifestContent = `
-  {
-    basePath: '${baseHref ?? '/'}',
-    entryPoints: new Map([${entryPointsContent.join(', \n')}]),
-  }
-`;
+export default {
+  basePath: '${baseHref ?? '/'}',
+  entryPoints: new Map([${entryPointsContent.join(', \n')}]),
+  staticPathsHeaders: new Map([${staticHeaders.join(', \n')}]),
+};
+  `;
     return manifestContent;
 }
 /**
@@ -62,16 +98,19 @@ function generateAngularServerAppEngineManifest(i18nOptions, baseHref) {
  * in the server-side rendered pages.
  * @param routes - An optional array of route definitions for the application, used for
  * server-side rendering and routing.
+ * @param locale - An optional string representing the locale or language code to be used for
+ * the application, helping with localization and rendering content specific to the locale.
+ *
  * @returns A string representing the content of the SSR server manifest for the Node.js
  * environment.
  */
-function generateAngularServerAppManifest(additionalHtmlOutputFiles, outputFiles, inlineCriticalCss, routes) {
+function generateAngularServerAppManifest(additionalHtmlOutputFiles, outputFiles, inlineCriticalCss, routes, locale) {
     const serverAssetsContent = [];
     for (const file of [...additionalHtmlOutputFiles.values(), ...outputFiles]) {
         if (file.path === options_1.INDEX_HTML_SERVER ||
             file.path === options_1.INDEX_HTML_CSR ||
             (inlineCriticalCss && file.path.endsWith('.css'))) {
-            serverAssetsContent.push(`['${file.path}', async () => ${JSON.stringify(file.text)}]`);
+            serverAssetsContent.push(`['${file.path}', async () => \`${escapeUnsafeChars(file.text)}\`]`);
         }
     }
     const manifestContent = `
@@ -80,6 +119,7 @@ export default {
   inlineCriticalCss: ${inlineCriticalCss},
   routes: ${JSON.stringify(routes, undefined, 2)},
   assets: new Map([${serverAssetsContent.join(', \n')}]),
+  locale: ${locale !== undefined ? `'${locale}'` : undefined},
 };
 `;
     return manifestContent;

package/src/utils/server-rendering/models.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type { RenderMode, ɵextractRoutesAndCreateRouteTree } from '@angular/ssr';
+import { ESMInMemoryFileLoaderWorkerData } from './esm-in-memory-loader/loader-hooks';
+type Writeable<T extends readonly unknown[]> = T extends readonly (infer U)[] ? U[] : never;
+export interface RoutesExtractorWorkerData extends ESMInMemoryFileLoaderWorkerData {
+    assetFiles: Record</** Destination */ string, /** Source */ string>;
+}
+export type SerializableRouteTreeNode = ReturnType<Awaited<ReturnType<typeof ɵextractRoutesAndCreateRouteTree>>['routeTree']['toObject']>;
+export type WritableSerializableRouteTreeNode = Writeable<SerializableRouteTreeNode>;
+export interface RoutersExtractorWorkerResult {
+    serializedRouteTree: SerializableRouteTreeNode;
+    errors: string[];
+}
+/**
+ * Local copy of `RenderMode` exported from `@angular/ssr`.
+ * This constant is needed to handle interop between CommonJS (CJS) and ES Modules (ESM) formats.
+ *
+ * It maps `RenderMode` enum values to their corresponding numeric identifiers.
+ */
+export declare const RouteRenderMode: Record<keyof typeof RenderMode, RenderMode>;
+export {};

package/src/utils/server-rendering/models.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteRenderMode = void 0;
+/**
+ * Local copy of `RenderMode` exported from `@angular/ssr`.
+ * This constant is needed to handle interop between CommonJS (CJS) and ES Modules (ESM) formats.
+ *
+ * It maps `RenderMode` enum values to their corresponding numeric identifiers.
+ */
+exports.RouteRenderMode = {
+    AppShell: 0,
+    Server: 1,
+    Client: 2,
+    Prerender: 3,
+};

package/src/utils/server-rendering/prerender.d.ts

@@ -5,16 +5,13 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
+import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { OutputMode } from '../../builders/application/schema';
 import { BuildOutputFile } from '../../tools/esbuild/bundler-context';
 import { BuildOutputAsset } from '../../tools/esbuild/bundler-execution-result';
-import type { SerializableRouteTreeNode } from './routes-extractor-worker';
-interface PrerenderOptions {
-    routesFile?: string;
-    discoverRoutes?: boolean;
-}
-interface AppShellOptions {
-    route?: string;
-}
+import { SerializableRouteTreeNode } from './models';
+type PrerenderOptions = NormalizedApplicationBuildOptions['prerenderOptions'];
+type AppShellOptions = NormalizedApplicationBuildOptions['appShellOptions'];
 /**
  * Represents the output of a prerendering process.
  *
@@ -33,11 +30,10 @@ type PrerenderOutput = Record<string, {
     content: string;
     appShellRoute: boolean;
 }>;
-export declare function prerenderPages(workspaceRoot: string, baseHref: string, appShellOptions: AppShellOptions | undefined, prerenderOptions: PrerenderOptions | undefined, outputFiles: Readonly<BuildOutputFile[]>, assets: Readonly<BuildOutputAsset[]>, sourcemap?: boolean, maxThreads?: number, verbose?: boolean): Promise<{
+export declare function prerenderPages(workspaceRoot: string, baseHref: string, appShellOptions: AppShellOptions | undefined, prerenderOptions: PrerenderOptions | undefined, outputFiles: Readonly<BuildOutputFile[]>, assets: Readonly<BuildOutputAsset[]>, outputMode: OutputMode | undefined, sourcemap?: boolean, maxThreads?: number): Promise<{
     output: PrerenderOutput;
     warnings: string[];
     errors: string[];
-    prerenderedRoutes: Set<string>;
     serializableRouteTreeNode: SerializableRouteTreeNode;
 }>;
 export {};

package/src/utils/server-rendering/prerender.js

@@ -11,16 +11,19 @@ exports.prerenderPages = prerenderPages;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
+const schema_1 = require("../../builders/application/schema");
 const bundler_context_1 = require("../../tools/esbuild/bundler-context");
+const error_1 = require("../error");
 const url_1 = require("../url");
 const worker_pool_1 = require("../worker-pool");
-async function prerenderPages(workspaceRoot, baseHref, appShellOptions = {}, prerenderOptions = {}, outputFiles, assets, sourcemap = false, maxThreads = 1, verbose = false) {
+const models_1 = require("./models");
+async function prerenderPages(workspaceRoot, baseHref, appShellOptions, prerenderOptions, outputFiles, assets, outputMode, sourcemap = false, maxThreads = 1) {
     const outputFilesForWorker = {};
     const serverBundlesSourceMaps = new Map();
     const warnings = [];
     const errors = [];
     for (const { text, path, type } of outputFiles) {
-        if (type !== bundler_context_1.BuildOutputFileType.Server) {
+        if (type !== bundler_context_1.BuildOutputFileType.ServerApplication && type !== bundler_context_1.BuildOutputFileType.ServerRoot) {
             continue;
         }
         // Contains the server runnable application code
@@ -48,39 +51,57 @@ async function prerenderPages(workspaceRoot, baseHref, appShellOptions = {}, pre
         assetsReversed[addLeadingSlash(destination.replace(/\\/g, node_path_1.posix.sep))] = source;
     }
     // Get routes to prerender
-    const { routes: allRoutes, warnings: routesWarnings, errors: routesErrors, serializableRouteTreeNode, } = await getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, assetsReversed, appShellOptions, prerenderOptions, sourcemap, verbose);
-    if (routesErrors?.length) {
-        errors.push(...routesErrors);
-    }
-    if (routesWarnings?.length) {
-        warnings.push(...routesWarnings);
+    const { errors: extractionErrors, serializedRouteTree: serializableRouteTreeNode } = await getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, assetsReversed, appShellOptions, prerenderOptions, sourcemap, outputMode).catch((err) => {
+        return {
+            errors: [
+                `An error occurred while extracting routes.\n\n${err.stack ?? err.message ?? err}`,
+            ],
+            serializedRouteTree: [],
+        };
+    });
+    errors.push(...extractionErrors);
+    const serializableRouteTreeNodeForPrerender = [];
+    for (const metadata of serializableRouteTreeNode) {
+        if (outputMode !== schema_1.OutputMode.Static && metadata.redirectTo) {
+            // Skip redirects if output mode is not static.
+            continue;
+        }
+        if (metadata.route.includes('*')) {
+            // Skip catch all routes from prerender.
+            continue;
+        }
+        switch (metadata.renderMode) {
+            case undefined: /* Legacy building mode */
+            case models_1.RouteRenderMode.Prerender:
+            case models_1.RouteRenderMode.AppShell:
+                serializableRouteTreeNodeForPrerender.push(metadata);
+                break;
+            case models_1.RouteRenderMode.Server:
+                if (outputMode === schema_1.OutputMode.Static) {
+                    errors.push(`Route '${metadata.route}' is configured with server render mode, but the build 'outputMode' is set to 'static'.`);
+                }
+                break;
+        }
     }
-    if (allRoutes.size < 1 || errors.length > 0) {
+    if (!serializableRouteTreeNodeForPrerender.length || errors.length > 0) {
         return {
             errors,
             warnings,
             output: {},
             serializableRouteTreeNode,
-            prerenderedRoutes: allRoutes,
         };
     }
     // Render routes
-    const { errors: renderingErrors, output } = await renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, appShellOptions);
+    const { errors: renderingErrors, output } = await renderPages(baseHref, sourcemap, serializableRouteTreeNodeForPrerender, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, appShellOptions, outputMode);
     errors.push(...renderingErrors);
     return {
         errors,
         warnings,
         output,
         serializableRouteTreeNode,
-        prerenderedRoutes: allRoutes,
     };
 }
-class RoutesSet extends Set {
-    add(value) {
-        return super.add(addLeadingSlash(value));
-    }
-}
-async function renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, appShellOptions) {
+async function renderPages(baseHref, sourcemap, serializableRouteTreeNode, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, appShellOptions, outputMode) {
     const output = {};
     const errors = [];
     const workerExecArgv = [
@@ -93,27 +114,35 @@ async function renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspace
     }
     const renderWorker = new worker_pool_1.WorkerPool({
         filename: require.resolve('./render-worker'),
-        maxThreads: Math.min(allRoutes.size, maxThreads),
+        maxThreads: Math.min(serializableRouteTreeNode.length, maxThreads),
         workerData: {
             workspaceRoot,
             outputFiles: outputFilesForWorker,
             assetFiles: assetFilesForWorker,
+            outputMode,
+            hasSsrEntry: !!outputFilesForWorker['/server.mjs'],
         },
         execArgv: workerExecArgv,
     });
     try {
         const renderingPromises = [];
-        const appShellRoute = appShellOptions.route && addLeadingSlash(appShellOptions.route);
+        const appShellRoute = appShellOptions && addLeadingSlash(appShellOptions.route);
         const baseHrefWithLeadingSlash = addLeadingSlash(baseHref);
-        for (const route of allRoutes) {
+        for (const { route, redirectTo, renderMode } of serializableRouteTreeNode) {
             // Remove base href from file output path.
             const routeWithoutBaseHref = addLeadingSlash(route.slice(baseHrefWithLeadingSlash.length - 1));
-            const render = renderWorker.run({ url: route });
+            const outPath = node_path_1.posix.join(removeLeadingSlash(routeWithoutBaseHref), 'index.html');
+            if (typeof redirectTo === 'string') {
+                output[outPath] = { content: generateRedirectStaticPage(redirectTo), appShellRoute: false };
+                continue;
+            }
+            const isAppShellRoute = renderMode === models_1.RouteRenderMode.AppShell ||
+                // Legacy handling
+                (renderMode === undefined && appShellRoute === routeWithoutBaseHref);
+            const render = renderWorker.run({ url: route, isAppShellRoute });
             const renderResult = render
                 .then((content) => {
                 if (content !== null) {
-                    const outPath = node_path_1.posix.join(removeLeadingSlash(routeWithoutBaseHref), 'index.html');
-                    const isAppShellRoute = appShellRoute === routeWithoutBaseHref;
                     output[outPath] = { content, appShellRoute: isAppShellRoute };
                 }
             })
@@ -133,21 +162,24 @@ async function renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspace
         output,
     };
 }
-async function getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, assetFilesForWorker, appShellOptions, prerenderOptions, sourcemap, verbose) {
-    const { routesFile, discoverRoutes } = prerenderOptions;
-    const routes = new RoutesSet();
-    const { route: appShellRoute } = appShellOptions;
-    if (appShellRoute !== undefined) {
-        routes.add((0, url_1.urlJoin)(baseHref, appShellRoute));
+async function getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, assetFilesForWorker, appShellOptions, prerenderOptions, sourcemap, outputMode) {
+    const { routesFile, discoverRoutes } = prerenderOptions ?? {};
+    const routes = [];
+    if (appShellOptions) {
+        routes.push({
+            route: (0, url_1.urlJoin)(baseHref, appShellOptions.route),
+        });
     }
     if (routesFile) {
         const routesFromFile = (await (0, promises_1.readFile)(routesFile, 'utf8')).split(/\r?\n/);
         for (const route of routesFromFile) {
-            routes.add((0, url_1.urlJoin)(baseHref, route.trim()));
+            routes.push({
+                route: (0, url_1.urlJoin)(baseHref, route.trim()),
+            });
         }
     }
     if (!discoverRoutes) {
-        return { routes, serializableRouteTreeNode: [] };
+        return { errors: [], serializedRouteTree: routes };
     }
     const workerExecArgv = [
         '--import',
@@ -164,42 +196,25 @@ async function getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, asset
             workspaceRoot,
             outputFiles: outputFilesForWorker,
             assetFiles: assetFilesForWorker,
+            outputMode,
+            hasSsrEntry: !!outputFilesForWorker['/server.mjs'],
         },
         execArgv: workerExecArgv,
     });
-    const errors = [];
-    const { serializedRouteTree: serializableRouteTreeNode } = await renderWorker
-        .run({})
-        .catch((err) => {
-        errors.push(`An error occurred while extracting routes.\n\n${err.stack}`);
-    })
-        .finally(() => {
-        void renderWorker.destroy();
-    });
-    const skippedRedirects = [];
-    const skippedOthers = [];
-    for (const { route, redirectTo } of serializableRouteTreeNode) {
-        if (redirectTo) {
-            skippedRedirects.push(route);
-        }
-        else if (route.includes('*')) {
-            skippedOthers.push(route);
-        }
-        else {
-            routes.add(route);
-        }
+    try {
+        const { serializedRouteTree, errors } = await renderWorker.run({});
+        return { errors, serializedRouteTree: [...routes, ...serializedRouteTree] };
     }
-    let warnings;
-    if (verbose) {
-        if (skippedOthers.length) {
-            (warnings ??= []).push('The following routes were skipped from prerendering because they contain routes with dynamic parameters:\n' +
-                skippedOthers.join('\n'));
-        }
-        if (skippedRedirects.length) {
-            (warnings ??= []).push('The following routes were skipped from prerendering because they contain redirects:\n', skippedRedirects.join('\n'));
-        }
+    catch (err) {
+        (0, error_1.assertIsError)(err);
+        return {
+            errors: [`An error occurred while extracting routes.\n\n${err.stack}`],
+            serializedRouteTree: [],
+        };
+    }
+    finally {
+        void renderWorker.destroy();
     }
-    return { routes, serializableRouteTreeNode, warnings };
 }
 function addLeadingSlash(value) {
     return value.charAt(0) === '/' ? value : '/' + value;
@@ -207,3 +222,27 @@ function addLeadingSlash(value) {
 function removeLeadingSlash(value) {
     return value.charAt(0) === '/' ? value.slice(1) : value;
 }
+/**
+ * Generates a static HTML page with a meta refresh tag to redirect the user to a specified URL.
+ *
+ * This function creates a simple HTML page that performs a redirect using a meta tag.
+ * It includes a fallback link in case the meta-refresh doesn't work.
+ *
+ * @param url - The URL to which the page should redirect.
+ * @returns The HTML content of the static redirect page.
+ */
+function generateRedirectStaticPage(url) {
+    return `
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Redirecting</title>
+    <meta http-equiv="refresh" content="0; url=${url}">
+  </head>
+  <body>
+    <pre>Redirecting to <a href="${url}">${url}</a></pre>
+  </body>
+</html>
+`.trim();
+}

package/src/utils/server-rendering/render-worker.d.ts

@@ -5,9 +5,12 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
+import type { OutputMode } from '../../builders/application/schema';
 import type { ESMInMemoryFileLoaderWorkerData } from './esm-in-memory-loader/loader-hooks';
 export interface RenderWorkerData extends ESMInMemoryFileLoaderWorkerData {
     assetFiles: Record</** Destination */ string, /** Source */ string>;
+    outputMode: OutputMode | undefined;
+    hasSsrEntry: boolean;
 }
 export interface RenderOptions {
     url: string;
@@ -16,5 +19,5 @@ export interface RenderOptions {
  * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
  */
 declare function renderPage({ url }: RenderOptions): Promise<string | null>;
-declare const _default: typeof renderPage;
+declare const _default: Promise<typeof renderPage>;
 export default _default;

package/src/utils/server-rendering/render-worker.js

@@ -7,19 +7,29 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
 const fetch_patch_1 = require("./fetch-patch");
+const launch_server_1 = require("./launch-server");
 const load_esm_from_memory_1 = require("./load-esm-from-memory");
+/**
+ * This is passed as workerData when setting up the worker via the `piscina` package.
+ */
+const { outputMode, hasSsrEntry } = worker_threads_1.workerData;
+let serverURL = launch_server_1.DEFAULT_URL;
 /**
  * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
  */
 async function renderPage({ url }) {
     const { ɵgetOrCreateAngularServerApp: getOrCreateAngularServerApp } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./main.server.mjs');
     const angularServerApp = getOrCreateAngularServerApp();
-    const response = await angularServerApp.renderStatic(new URL(url, 'http://local-angular-prerender'), AbortSignal.timeout(30_000));
+    const response = await angularServerApp.renderStatic(new URL(url, serverURL), AbortSignal.timeout(30_000));
     return response ? response.text() : null;
 }
-function initialize() {
-    (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)();
+async function initialize() {
+    if (outputMode !== undefined && hasSsrEntry) {
+        serverURL = await (0, launch_server_1.launchServer)();
+    }
+    (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)(serverURL);
     return renderPage;
 }
 exports.default = initialize();