@angular/build 19.0.0-next.2 → 19.0.0-next.4

package/src/utils/server-rendering/fetch-patch.js

@@ -17,7 +17,6 @@ const node_worker_threads_1 = require("node:worker_threads");
  */
 const { assetFiles } = node_worker_threads_1.workerData;
 const assetsCache = new Map();
-const RESOLVE_PROTOCOL = 'resolve:';
 function patchFetchToLoadInMemoryAssets() {
     const originalFetch = globalThis.fetch;
     const patchedFetch = async (input, init) => {
@@ -26,17 +25,17 @@ function patchFetchToLoadInMemoryAssets() {
             url = input;
         }
         else if (typeof input === 'string') {
-            url = new URL(input, RESOLVE_PROTOCOL + '//');
+            url = new URL(input);
         }
         else if (typeof input === 'object' && 'url' in input) {
-            url = new URL(input.url, RESOLVE_PROTOCOL + '//');
+            url = new URL(input.url);
         }
         else {
             return originalFetch(input, init);
         }
-        const { protocol } = url;
+        const { hostname } = url;
         const pathname = decodeURIComponent(url.pathname);
-        if (protocol !== RESOLVE_PROTOCOL || !assetFiles[pathname]) {
+        if (hostname !== 'local-angular-prerender' || !assetFiles[pathname]) {
             // Only handle relative requests or files that are in assets.
             return originalFetch(input, init);
         }

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

@@ -5,6 +5,16 @@
  * 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 { MainServerBundleExports, RenderUtilsServerBundleExports } from './main-bundle-exports';
+import type { ApplicationRef, Type } from '@angular/core';
+import type { ɵServerRenderContext, ɵextractRoutesAndCreateRouteTree, ɵgetOrCreateAngularServerApp } from '@angular/ssr';
+/**
+ * Represents the exports available from the main server bundle.
+ */
+interface MainServerBundleExports {
+    default: (() => Promise<ApplicationRef>) | Type<unknown>;
+    ɵServerRenderContext: typeof ɵServerRenderContext;
+    ɵextractRoutesAndCreateRouteTree: typeof ɵextractRoutesAndCreateRouteTree;
+    ɵgetOrCreateAngularServerApp: typeof ɵgetOrCreateAngularServerApp;
+}
 export declare function loadEsmModuleFromMemory(path: './main.server.mjs'): Promise<MainServerBundleExports>;
-export declare function loadEsmModuleFromMemory(path: './render-utils.server.mjs'): Promise<RenderUtilsServerBundleExports>;
+export {};

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

@@ -0,0 +1,44 @@
+/**
+ * @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 { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import type { BuildOutputFile } from '../../tools/esbuild/bundler-context';
+export declare const SERVER_APP_MANIFEST_FILENAME = "angular-app-manifest.mjs";
+/**
+ * Generates the server manifest for the App Engine environment.
+ *
+ * This manifest is used to configure the server-side rendering (SSR) setup for the
+ * Angular application when deployed to Google App Engine. It includes the entry points
+ * for different locales and the base HREF for the application.
+ *
+ * @param i18nOptions - The internationalization options for the application build. This
+ * 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.
+ * @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;
+/**
+ * Generates the server manifest for the standard Node.js environment.
+ *
+ * This manifest is used to configure the server-side rendering (SSR) setup for the
+ * Angular application when running in a standard Node.js environment. It includes
+ * information about the bootstrap module, whether to inline critical CSS, and any
+ * additional HTML and CSS output files.
+ *
+ * @param additionalHtmlOutputFiles - A map of additional HTML output files generated
+ * during the build process, keyed by their file paths.
+ * @param outputFiles - An array of all output files from the build process, including
+ * JavaScript and CSS files.
+ * @param inlineCriticalCss - A boolean indicating whether critical CSS should be inlined
+ * in the server-side rendered pages.
+ * @param routes - An optional array of route definitions for the application, used for
+ * server-side rendering and routing.
+ * @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;

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

@@ -0,0 +1,86 @@
+"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.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';
+const MAIN_SERVER_OUTPUT_FILENAME = 'main.server.mjs';
+/**
+ * Generates the server manifest for the App Engine environment.
+ *
+ * This manifest is used to configure the server-side rendering (SSR) setup for the
+ * Angular application when deployed to Google App Engine. It includes the entry points
+ * for different locales and the base HREF for the application.
+ *
+ * @param i18nOptions - The internationalization options for the application build. This
+ * 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.
+ * @returns A string representing the content of the SSR server manifest for App Engine.
+ */
+function generateAngularServerAppEngineManifest(i18nOptions, baseHref) {
+    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}')]`);
+        }
+    }
+    else {
+        entryPointsContent.push(`['/', () => import('./${MAIN_SERVER_OUTPUT_FILENAME}')]`);
+    }
+    const manifestContent = `
+  {
+    basePath: '${baseHref ?? '/'}',
+    entryPoints: new Map([${entryPointsContent.join(', \n')}]),
+  }
+`;
+    return manifestContent;
+}
+/**
+ * Generates the server manifest for the standard Node.js environment.
+ *
+ * This manifest is used to configure the server-side rendering (SSR) setup for the
+ * Angular application when running in a standard Node.js environment. It includes
+ * information about the bootstrap module, whether to inline critical CSS, and any
+ * additional HTML and CSS output files.
+ *
+ * @param additionalHtmlOutputFiles - A map of additional HTML output files generated
+ * during the build process, keyed by their file paths.
+ * @param outputFiles - An array of all output files from the build process, including
+ * JavaScript and CSS files.
+ * @param inlineCriticalCss - A boolean indicating whether critical CSS should be inlined
+ * in the server-side rendered pages.
+ * @param routes - An optional array of route definitions for the application, used for
+ * server-side rendering and routing.
+ * @returns A string representing the content of the SSR server manifest for the Node.js
+ * environment.
+ */
+function generateAngularServerAppManifest(additionalHtmlOutputFiles, outputFiles, inlineCriticalCss, routes) {
+    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)}]`);
+        }
+    }
+    const manifestContent = `
+export default {
+  bootstrap: () => import('./main.server.mjs').then(m => m.default),
+  inlineCriticalCss: ${inlineCriticalCss},
+  routes: ${JSON.stringify(routes, undefined, 2)},
+  assets: new Map([${serverAssetsContent.join(', \n')}]),
+};
+`;
+    return manifestContent;
+}

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

@@ -7,6 +7,7 @@
  */
 import { BuildOutputFile } from '../../tools/esbuild/bundler-context';
 import { BuildOutputAsset } from '../../tools/esbuild/bundler-execution-result';
+import type { RoutersExtractorWorkerResult as SerializableRouteTreeNode } from './routes-extractor-worker';
 interface PrerenderOptions {
     routesFile?: string;
     discoverRoutes?: boolean;
@@ -14,10 +15,29 @@ interface PrerenderOptions {
 interface AppShellOptions {
     route?: string;
 }
-export declare function prerenderPages(workspaceRoot: string, appShellOptions: AppShellOptions | undefined, prerenderOptions: PrerenderOptions | undefined, outputFiles: Readonly<BuildOutputFile[]>, assets: Readonly<BuildOutputAsset[]>, document: string, sourcemap?: boolean, inlineCriticalCss?: boolean, maxThreads?: number, verbose?: boolean): Promise<{
-    output: Record<string, string>;
+/**
+ * Represents the output of a prerendering process.
+ *
+ * The key is the file path, and the value is an object containing the following properties:
+ *
+ * - `content`: The HTML content or output generated for the corresponding file path.
+ * - `appShellRoute`: A boolean flag indicating whether the content is an app shell.
+ *
+ * @example
+ * {
+ *   '/index.html': { content: '<html>...</html>', appShell: false },
+ *   '/shell/index.html': { content: '<html>...</html>', appShellRoute: true }
+ * }
+ */
+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<{
+    output: PrerenderOutput;
     warnings: string[];
     errors: string[];
     prerenderedRoutes: Set<string>;
+    serializableRouteTreeNode: SerializableRouteTreeNode;
 }>;
 export {};

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

@@ -16,19 +16,21 @@ const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
 const piscina_1 = __importDefault(require("piscina"));
 const bundler_context_1 = require("../../tools/esbuild/bundler-context");
-async function prerenderPages(workspaceRoot, appShellOptions = {}, prerenderOptions = {}, outputFiles, assets, document, sourcemap = false, inlineCriticalCss = false, maxThreads = 1, verbose = false) {
+const url_1 = require("../url");
+async function prerenderPages(workspaceRoot, baseHref, appShellOptions = {}, prerenderOptions = {}, outputFiles, assets, sourcemap = false, maxThreads = 1, verbose = false) {
     const outputFilesForWorker = {};
     const serverBundlesSourceMaps = new Map();
     const warnings = [];
     const errors = [];
     for (const { text, path, type } of outputFiles) {
-        const fileExt = (0, node_path_1.extname)(path);
-        if (type === bundler_context_1.BuildOutputFileType.Server && fileExt === '.map') {
+        if (type !== bundler_context_1.BuildOutputFileType.Server) {
+            continue;
+        }
+        // Contains the server runnable application code
+        if ((0, node_path_1.extname)(path) === '.map') {
             serverBundlesSourceMaps.set(path.slice(0, -4), text);
         }
-        else if (type === bundler_context_1.BuildOutputFileType.Server || // Contains the server runnable application code
-            (type === bundler_context_1.BuildOutputFileType.Browser && fileExt === '.css') // Global styles for critical CSS inlining.
-        ) {
+        else {
             outputFilesForWorker[path] = text;
         }
     }
@@ -49,7 +51,7 @@ async function prerenderPages(workspaceRoot, appShellOptions = {}, prerenderOpti
         assetsReversed[addLeadingSlash(destination.replace(/\\/g, node_path_1.posix.sep))] = source;
     }
     // Get routes to prerender
-    const { routes: allRoutes, warnings: routesWarnings, errors: routesErrors, } = await getAllRoutes(workspaceRoot, outputFilesForWorker, assetsReversed, document, appShellOptions, prerenderOptions, sourcemap, verbose);
+    const { routes: allRoutes, warnings: routesWarnings, errors: routesErrors, serializableRouteTreeNode, } = await getAllRoutes(workspaceRoot, baseHref, outputFilesForWorker, assetsReversed, appShellOptions, prerenderOptions, sourcemap, verbose);
     if (routesErrors?.length) {
         errors.push(...routesErrors);
     }
@@ -61,17 +63,18 @@ async function prerenderPages(workspaceRoot, appShellOptions = {}, prerenderOpti
             errors,
             warnings,
             output: {},
+            serializableRouteTreeNode,
             prerenderedRoutes: allRoutes,
         };
     }
     // Render routes
-    const { warnings: renderingWarnings, errors: renderingErrors, output, } = await renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, inlineCriticalCss, document, appShellOptions);
+    const { errors: renderingErrors, output } = await renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, appShellOptions);
     errors.push(...renderingErrors);
-    warnings.push(...renderingWarnings);
     return {
         errors,
         warnings,
         output,
+        serializableRouteTreeNode,
         prerenderedRoutes: allRoutes,
     };
 }
@@ -80,9 +83,8 @@ class RoutesSet extends Set {
         return super.add(addLeadingSlash(value));
     }
 }
-async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, inlineCriticalCss, document, appShellOptions) {
+async function renderPages(baseHref, sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, appShellOptions) {
     const output = {};
-    const warnings = [];
     const errors = [];
     const workerExecArgv = [
         '--import',
@@ -99,8 +101,6 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
             workspaceRoot,
             outputFiles: outputFilesForWorker,
             assetFiles: assetFilesForWorker,
-            inlineCriticalCss,
-            document,
         },
         execArgv: workerExecArgv,
         recordTiming: false,
@@ -108,27 +108,21 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
     try {
         const renderingPromises = [];
         const appShellRoute = appShellOptions.route && addLeadingSlash(appShellOptions.route);
+        const baseHrefWithLeadingSlash = addLeadingSlash(baseHref);
         for (const route of allRoutes) {
-            const isAppShellRoute = appShellRoute === route;
-            const serverContext = isAppShellRoute ? 'app-shell' : 'ssg';
-            const render = renderWorker.run({ route, serverContext });
+            // Remove base href from file output path.
+            const routeWithoutBaseHref = addLeadingSlash(route.slice(baseHrefWithLeadingSlash.length - 1));
+            const isAppShellRoute = appShellRoute === routeWithoutBaseHref;
+            const render = renderWorker.run({ url: route, isAppShellRoute });
             const renderResult = render
-                .then(({ content, warnings, errors }) => {
-                if (content !== undefined) {
-                    const outPath = isAppShellRoute
-                        ? 'index.html'
-                        : node_path_1.posix.join(removeLeadingSlash(route), 'index.html');
-                    output[outPath] = content;
-                }
-                if (warnings) {
-                    warnings.push(...warnings);
-                }
-                if (errors) {
-                    errors.push(...errors);
+                .then((content) => {
+                if (content !== null) {
+                    const outPath = node_path_1.posix.join(removeLeadingSlash(routeWithoutBaseHref), 'index.html');
+                    output[outPath] = { content, appShellRoute: isAppShellRoute };
                 }
             })
                 .catch((err) => {
-                errors.push(`An error occurred while prerendering route '${route}'.\n\n${err.stack}`);
+                errors.push(`An error occurred while prerendering route '${route}'.\n\n${err.stack ?? err.message ?? err.code ?? err}`);
                 void renderWorker.destroy();
             });
             renderingPromises.push(renderResult);
@@ -140,25 +134,24 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
     }
     return {
         errors,
-        warnings,
         output,
     };
 }
-async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWorker, document, appShellOptions, prerenderOptions, sourcemap, verbose) {
+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(appShellRoute);
+        routes.add((0, url_1.urlJoin)(baseHref, appShellRoute));
     }
     if (routesFile) {
         const routesFromFile = (await (0, promises_1.readFile)(routesFile, 'utf8')).split(/\r?\n/);
         for (const route of routesFromFile) {
-            routes.add(route.trim());
+            routes.add((0, url_1.urlJoin)(baseHref, route.trim()));
         }
     }
     if (!discoverRoutes) {
-        return { routes };
+        return { routes, serializableRouteTreeNode: [] };
     }
     const workerExecArgv = [
         '--import',
@@ -175,14 +168,12 @@ async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWo
             workspaceRoot,
             outputFiles: outputFilesForWorker,
             assetFiles: assetFilesForWorker,
-            document,
-            verbose,
         },
         execArgv: workerExecArgv,
         recordTiming: false,
     });
     const errors = [];
-    const { routes: extractedRoutes, warnings } = await renderWorker
+    const serializableRouteTreeNode = await renderWorker
         .run({})
         .catch((err) => {
         errors.push(`An error occurred while extracting routes.\n\n${err.stack}`);
@@ -190,10 +181,30 @@ async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWo
         .finally(() => {
         void renderWorker.destroy();
     });
-    for (const route of extractedRoutes) {
-        routes.add(route);
+    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);
+        }
+    }
+    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'));
+        }
     }
-    return { routes, warnings, errors };
+    return { routes, serializableRouteTreeNode, warnings };
 }
 function addLeadingSlash(value) {
     return value.charAt(0) === '/' ? value : '/' + value;

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

@@ -6,17 +6,16 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { ESMInMemoryFileLoaderWorkerData } from './esm-in-memory-loader/loader-hooks';
-import { RenderResult, ServerContext } from './render-page';
 export interface RenderWorkerData extends ESMInMemoryFileLoaderWorkerData {
-    document: string;
-    inlineCriticalCss?: boolean;
     assetFiles: Record</** Destination */ string, /** Source */ string>;
 }
 export interface RenderOptions {
-    route: string;
-    serverContext: ServerContext;
+    url: string;
+    isAppShellRoute: boolean;
 }
-/** Renders an application based on a provided options. */
-declare function render(options: RenderOptions): Promise<RenderResult>;
-declare const _default: typeof render;
+/**
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
+ */
+declare function renderPage({ url, isAppShellRoute }: RenderOptions): Promise<string | null>;
+declare const _default: typeof renderPage;
 export default _default;

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

@@ -7,24 +7,21 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_worker_threads_1 = require("node:worker_threads");
 const fetch_patch_1 = require("./fetch-patch");
-const render_page_1 = require("./render-page");
+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.
+ * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
  */
-const { outputFiles, document, inlineCriticalCss } = node_worker_threads_1.workerData;
-/** Renders an application based on a provided options. */
-function render(options) {
-    return (0, render_page_1.renderPage)({
-        ...options,
-        outputFiles,
-        document,
-        inlineCriticalCss,
-    });
+async function renderPage({ url, isAppShellRoute }) {
+    const { ɵgetOrCreateAngularServerApp: getOrCreateAngularServerApp, ɵServerRenderContext: ServerRenderContext, } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./main.server.mjs');
+    const angularServerApp = getOrCreateAngularServerApp();
+    const response = await angularServerApp.render(new Request(new URL(url, 'http://local-angular-prerender'), {
+        signal: AbortSignal.timeout(30_000),
+    }), undefined, isAppShellRoute ? ServerRenderContext.AppShell : ServerRenderContext.SSG);
+    return response ? response.text() : null;
 }
 function initialize() {
     (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)();
-    return render;
+    return renderPage;
 }
 exports.default = initialize();

package/src/utils/server-rendering/routes-extractor-worker.d.ts

@@ -5,16 +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 { ɵextractRoutesAndCreateRouteTree } from '@angular/ssr';
 import type { ESMInMemoryFileLoaderWorkerData } from './esm-in-memory-loader/loader-hooks';
 export interface RoutesExtractorWorkerData extends ESMInMemoryFileLoaderWorkerData {
-    document: string;
-    verbose: boolean;
     assetFiles: Record</** Destination */ string, /** Source */ string>;
 }
-export interface RoutersExtractorWorkerResult {
-    routes: string[];
-    warnings?: string[];
-}
+export type RoutersExtractorWorkerResult = ReturnType<Awaited<ReturnType<typeof ɵextractRoutesAndCreateRouteTree>>['toObject']>;
 /** Renders an application based on a provided options. */
 declare function extractRoutes(): Promise<RoutersExtractorWorkerResult>;
 declare const _default: typeof extractRoutes;

package/src/utils/server-rendering/routes-extractor-worker.js

@@ -7,44 +7,13 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_worker_threads_1 = require("node:worker_threads");
 const fetch_patch_1 = require("./fetch-patch");
 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 { document, verbose } = node_worker_threads_1.workerData;
 /** Renders an application based on a provided options. */
 async function extractRoutes() {
-    const { ɵgetRoutesFromAngularRouterConfig: getRoutesFromAngularRouterConfig } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./render-utils.server.mjs');
-    const { default: bootstrapAppFnOrModule } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./main.server.mjs');
-    const skippedRedirects = [];
-    const skippedOthers = [];
-    const routes = [];
-    const { routes: extractRoutes } = await getRoutesFromAngularRouterConfig(bootstrapAppFnOrModule, document, new URL('http://localhost'));
-    for (const { route, redirectTo } of extractRoutes) {
-        if (redirectTo !== undefined) {
-            skippedRedirects.push(route);
-        }
-        else if (/[:*]/.test(route)) {
-            skippedOthers.push(route);
-        }
-        else {
-            routes.push(route);
-        }
-    }
-    if (!verbose) {
-        return { routes };
-    }
-    let warnings;
-    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'));
-    }
-    return { routes, warnings };
+    const { ɵextractRoutesAndCreateRouteTree: extractRoutesAndCreateRouteTree } = await (0, load_esm_from_memory_1.loadEsmModuleFromMemory)('./main.server.mjs');
+    const routeTree = await extractRoutesAndCreateRouteTree(new URL('http://local-angular-prerender/'));
+    return routeTree.toObject();
 }
 function initialize() {
     (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)();

package/src/utils/server-rendering/main-bundle-exports.d.ts

@@ -1,27 +0,0 @@
-/**
- * @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 { ApplicationRef, Type, ɵConsole } from '@angular/core';
-import type { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';
-import type { ɵgetRoutesFromAngularRouterConfig } from '@angular/ssr';
-export interface MainServerBundleExports {
-    /** Standalone application bootstrapping function. */
-    default: (() => Promise<ApplicationRef>) | Type<unknown>;
-}
-export interface RenderUtilsServerBundleExports {
-    /** An internal token that allows providing extra information about the server context. */
-    ɵSERVER_CONTEXT: typeof ɵSERVER_CONTEXT;
-    /** Render an NgModule application. */
-    renderModule: typeof renderModule;
-    /** Method to render a standalone application. */
-    renderApplication: typeof renderApplication;
-    /** Method to extract routes from the router config. */
-    ɵgetRoutesFromAngularRouterConfig: typeof ɵgetRoutesFromAngularRouterConfig;
-    ɵresetCompiledComponents?: () => void;
-    /** Angular Console token/class. */
-    ɵConsole: typeof ɵConsole;
-}

package/src/utils/server-rendering/main-bundle-exports.js

@@ -1,9 +0,0 @@
-"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 });

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

@@ -1,26 +0,0 @@
-/**
- * @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 { MainServerBundleExports, RenderUtilsServerBundleExports } from './main-bundle-exports';
-export interface RenderOptions {
-    route: string;
-    serverContext: ServerContext;
-    outputFiles: Record<string, string>;
-    document: string;
-    inlineCriticalCss?: boolean;
-    loadBundle?: ((path: './main.server.mjs') => Promise<MainServerBundleExports>) & ((path: './render-utils.server.mjs') => Promise<RenderUtilsServerBundleExports>);
-}
-export interface RenderResult {
-    errors?: string[];
-    warnings?: string[];
-    content?: string;
-}
-export type ServerContext = 'app-shell' | 'ssg' | 'ssr';
-/**
- * Renders each route in routes and writes them to <outputPath>/<route>/index.html.
- */
-export declare function renderPage({ route, serverContext, document, inlineCriticalCss, outputFiles, loadBundle, }: RenderOptions): Promise<RenderResult>;