@angular/build 19.0.0-next.0 → 19.0.0-next.10

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

@@ -6,29 +6,31 @@
  * 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.prerenderPages = prerenderPages;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
-const piscina_1 = __importDefault(require("piscina"));
+const schema_1 = require("../../builders/application/schema");
 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 error_1 = require("../error");
+const url_1 = require("../url");
+const worker_pool_1 = require("../worker-pool");
+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) {
-        const fileExt = (0, node_path_1.extname)(path);
-        if (type === bundler_context_1.BuildOutputFileType.Server && fileExt === '.map') {
+        if (type !== bundler_context_1.BuildOutputFileType.ServerApplication && type !== bundler_context_1.BuildOutputFileType.ServerRoot) {
+            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,37 +51,58 @@ 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 } = await getAllRoutes(workspaceRoot, outputFilesForWorker, assetsReversed, document, appShellOptions, prerenderOptions, sourcemap, verbose);
-    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) {
+    if (!serializableRouteTreeNodeForPrerender.length || errors.length > 0) {
         return {
             errors,
             warnings,
             output: {},
-            prerenderedRoutes: allRoutes,
+            serializableRouteTreeNode,
         };
     }
     // 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, serializableRouteTreeNodeForPrerender, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, appShellOptions, outputMode);
     errors.push(...renderingErrors);
-    warnings.push(...renderingWarnings);
     return {
         errors,
         warnings,
         output,
-        prerenderedRoutes: allRoutes,
+        serializableRouteTreeNode,
     };
 }
-class RoutesSet extends Set {
-    add(value) {
-        return super.add(addLeadingSlash(value));
-    }
-}
-async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, inlineCriticalCss, document, appShellOptions) {
+async function renderPages(baseHref, sourcemap, serializableRouteTreeNode, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, appShellOptions, outputMode) {
     const output = {};
-    const warnings = [];
     const errors = [];
     const workerExecArgv = [
         '--import',
@@ -89,39 +112,43 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
     if (sourcemap) {
         workerExecArgv.push('--enable-source-maps');
     }
-    const renderWorker = new piscina_1.default({
+    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,
-            inlineCriticalCss,
-            document,
+            outputMode,
+            hasSsrEntry: !!outputFilesForWorker['server.mjs'],
         },
         execArgv: workerExecArgv,
-        recordTiming: false,
     });
     try {
         const renderingPromises = [];
-        const appShellRoute = appShellOptions.route && addLeadingSlash(appShellOptions.route);
-        for (const route of allRoutes) {
-            const isAppShellRoute = appShellRoute === route;
-            const serverContext = isAppShellRoute ? 'app-shell' : 'ssg';
-            const render = renderWorker.run({ route, serverContext });
-            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);
+        const appShellRoute = appShellOptions && addLeadingSlash(appShellOptions.route);
+        const baseHrefWithLeadingSlash = addLeadingSlash(baseHref);
+        for (const { route, redirectTo, renderMode } of serializableRouteTreeNode) {
+            // Remove base href from file output path.
+            const routeWithoutBaseHref = addLeadingSlash(route.slice(baseHrefWithLeadingSlash.length - 1));
+            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) {
+                    output[outPath] = { content, appShellRoute: isAppShellRoute };
                 }
+            })
+                .catch((err) => {
+                errors.push(`An error occurred while prerendering route '${route}'.\n\n${err.stack ?? err.message ?? err.code ?? err}`);
+                void renderWorker.destroy();
             });
             renderingPromises.push(renderResult);
         }
@@ -132,25 +159,27 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
     }
     return {
         errors,
-        warnings,
         output,
     };
 }
-async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWorker, document, appShellOptions, prerenderOptions, sourcemap, verbose) {
-    const { routesFile, discoverRoutes } = prerenderOptions;
-    const routes = new RoutesSet();
-    const { route: appShellRoute } = appShellOptions;
-    if (appShellRoute !== undefined) {
-        routes.add(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(route.trim());
+            routes.push({
+                route: (0, url_1.urlJoin)(baseHref, route.trim()),
+            });
         }
     }
     if (!discoverRoutes) {
-        return { routes };
+        return { errors: [], serializedRouteTree: routes };
     }
     const workerExecArgv = [
         '--import',
@@ -160,28 +189,34 @@ async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWo
     if (sourcemap) {
         workerExecArgv.push('--enable-source-maps');
     }
-    const renderWorker = new piscina_1.default({
+    const renderWorker = new worker_pool_1.WorkerPool({
         filename: require.resolve('./routes-extractor-worker'),
         maxThreads: 1,
         workerData: {
             workspaceRoot,
             outputFiles: outputFilesForWorker,
             assetFiles: assetFilesForWorker,
-            document,
-            verbose,
+            outputMode,
+            hasSsrEntry: !!outputFilesForWorker['server.mjs'],
         },
         execArgv: workerExecArgv,
-        recordTiming: false,
     });
-    const { routes: extractedRoutes, warnings } = await renderWorker
-        .run({})
-        .finally(() => {
+    try {
+        const { serializedRouteTree, errors } = await renderWorker.run({});
+        return { errors, serializedRouteTree: [...routes, ...serializedRouteTree] };
+    }
+    catch (err) {
+        (0, error_1.assertIsError)(err);
+        return {
+            errors: [
+                `An error occurred while extracting routes.\n\n${err.stack ?? err.message ?? err.code ?? err}`,
+            ],
+            serializedRouteTree: [],
+        };
+    }
+    finally {
         void renderWorker.destroy();
-    });
-    for (const route of extractedRoutes) {
-        routes.add(route);
     }
-    return { routes, warnings };
 }
 function addLeadingSlash(value) {
     return value.charAt(0) === '/' ? value : '/' + value;
@@ -189,3 +224,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,18 +5,19 @@
  * 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';
-import { RenderResult, ServerContext } from './render-page';
 export interface RenderWorkerData extends ESMInMemoryFileLoaderWorkerData {
-    document: string;
-    inlineCriticalCss?: boolean;
     assetFiles: Record</** Destination */ string, /** Source */ string>;
+    outputMode: OutputMode | undefined;
+    hasSsrEntry: boolean;
 }
 export interface RenderOptions {
-    route: string;
-    serverContext: ServerContext;
+    url: string;
 }
-/** 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 }: RenderOptions): Promise<string | null>;
+declare const _default: Promise<typeof renderPage>;
 export default _default;

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

@@ -7,24 +7,29 @@
  * 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 worker_threads_1 = require("worker_threads");
 const fetch_patch_1 = require("./fetch-patch");
-const render_page_1 = require("./render-page");
+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 { 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,
-    });
+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, serverURL), AbortSignal.timeout(30_000));
+    return response ? response.text() : null;
 }
-function initialize() {
-    (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)();
-    return render;
+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();

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

@@ -5,17 +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 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[];
+import { OutputMode } from '../../builders/application/schema';
+import { ESMInMemoryFileLoaderWorkerData } from './esm-in-memory-loader/loader-hooks';
+import { RoutersExtractorWorkerResult } from './models';
+export interface ExtractRoutesWorkerData extends ESMInMemoryFileLoaderWorkerData {
+    outputMode: OutputMode | undefined;
 }
 /** Renders an application based on a provided options. */
 declare function extractRoutes(): Promise<RoutersExtractorWorkerResult>;
-declare const _default: typeof extractRoutes;
+declare const _default: Promise<typeof extractRoutes>;
 export default _default;

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

@@ -7,47 +7,30 @@
  * 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 worker_threads_1 = require("worker_threads");
+const schema_1 = require("../../builders/application/schema");
 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 { document, verbose } = node_worker_threads_1.workerData;
+const { outputMode, hasSsrEntry } = worker_threads_1.workerData;
+let serverURL = launch_server_1.DEFAULT_URL;
 /** 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, errors } = await extractRoutesAndCreateRouteTree(serverURL, undefined /** manifest */, true /** invokeGetPrerenderParams */, outputMode === schema_1.OutputMode.Server /** includePrerenderFallbackRoutes */);
+    return {
+        errors,
+        serializedRouteTree: routeTree.toObject(),
+    };
 }
-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 extractRoutes;
 }
 exports.default = initialize();

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

@@ -0,0 +1,11 @@
+/**
+ * @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 { createRequestHandler } from '@angular/ssr';
+import type { createNodeRequestHandler } from '@angular/ssr/node';
+export declare function isSsrNodeRequestHandler(value: unknown): value is ReturnType<typeof createNodeRequestHandler>;
+export declare function isSsrRequestHandler(value: unknown): value is ReturnType<typeof createRequestHandler>;

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

@@ -0,0 +1,17 @@
+"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.isSsrNodeRequestHandler = isSsrNodeRequestHandler;
+exports.isSsrRequestHandler = isSsrRequestHandler;
+function isSsrNodeRequestHandler(value) {
+    return typeof value === 'function' && '__ng_node_request_handler__' in value;
+}
+function isSsrRequestHandler(value) {
+    return typeof value === 'function' && '__ng_request_handler__' in value;
+}

package/src/utils/worker-pool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { Piscina } from 'piscina';
+export type WorkerPoolOptions = ConstructorParameters<typeof Piscina>[0];
+export declare class WorkerPool extends Piscina {
+    constructor(options: WorkerPoolOptions);
+}

package/src/utils/worker-pool.js

@@ -0,0 +1,43 @@
+"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.WorkerPool = void 0;
+const node_module_1 = require("node:module");
+const piscina_1 = require("piscina");
+class WorkerPool extends piscina_1.Piscina {
+    constructor(options) {
+        const piscinaOptions = {
+            minThreads: 1,
+            idleTimeout: 1000,
+            // Web containers do not support transferable objects with receiveOnMessagePort which
+            // is used when the Atomics based wait loop is enable.
+            useAtomics: !process.versions.webcontainer,
+            recordTiming: false,
+            ...options,
+        };
+        // Enable compile code caching if enabled for the main process (only exists on Node.js v22.8+).
+        // Skip if running inside Bazel via a RUNFILES environment variable check. The cache does not work
+        // well with Bazel's hermeticity requirements.
+        const compileCacheDirectory = process.env['RUNFILES'] ? undefined : (0, node_module_1.getCompileCacheDir)?.();
+        if (compileCacheDirectory) {
+            if (typeof piscinaOptions.env === 'object') {
+                piscinaOptions.env['NODE_COMPILE_CACHE'] = compileCacheDirectory;
+            }
+            else {
+                // Default behavior of `env` option is to copy current process values
+                piscinaOptions.env = {
+                    ...process.env,
+                    'NODE_COMPILE_CACHE': compileCacheDirectory,
+                };
+            }
+        }
+        super(piscinaOptions);
+    }
+}
+exports.WorkerPool = WorkerPool;

package/src/tools/vite/angular-memory-plugin.d.ts

@@ -1,21 +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 { Connect, Plugin } from 'vite';
-import { AngularMemoryOutputFiles } from './utils';
-export interface AngularMemoryPluginOptions {
-    workspaceRoot: string;
-    virtualProjectRoot: string;
-    outputFiles: AngularMemoryOutputFiles;
-    assets: Map<string, string>;
-    ssr: boolean;
-    external?: string[];
-    extensionMiddleware?: Connect.NextHandleFunction[];
-    indexHtmlTransformer?: (content: string) => Promise<string>;
-    normalizePath: (path: string) => string;
-}
-export declare function createAngularMemoryPlugin(options: AngularMemoryPluginOptions): Plugin;

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/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>;