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

package/src/utils/index-file/inline-critical-css.js

@@ -22,38 +22,53 @@ const MEDIA_SET_HANDLER_PATTERN = /^this\.media=["'](.*)["'];?$/;
  */
 const CSP_MEDIA_ATTR = 'ngCspMedia';
 /**
- * Script text used to change the media value of the link tags.
+ * Script that dynamically updates the `media` attribute of `<link>` tags based on a custom attribute (`CSP_MEDIA_ATTR`).
  *
  * NOTE:
  * We do not use `document.querySelectorAll('link').forEach((s) => s.addEventListener('load', ...)`
- * because this does not always fire on Chome.
+ * because load events are not always triggered reliably on Chrome.
  * See: https://github.com/angular/angular-cli/issues/26932 and https://crbug.com/1521256
+ *
+ * The script:
+ * - Ensures the event target is a `<link>` tag with the `CSP_MEDIA_ATTR` attribute.
+ * - Updates the `media` attribute with the value of `CSP_MEDIA_ATTR` and then removes the attribute.
+ * - Removes the event listener when all relevant `<link>` tags have been processed.
+ * - Uses event capturing (the `true` parameter) since load events do not bubble up the DOM.
  */
-const LINK_LOAD_SCRIPT_CONTENT = [
-    '(() => {',
-    `  const CSP_MEDIA_ATTR = '${CSP_MEDIA_ATTR}';`,
-    '  const documentElement = document.documentElement;',
-    '  const listener = (e) => {',
-    '    const target = e.target;',
-    `    if (!target || target.tagName !== 'LINK' || !target.hasAttribute(CSP_MEDIA_ATTR)) {`,
-    '     return;',
-    '    }',
-    '    target.media = target.getAttribute(CSP_MEDIA_ATTR);',
-    '    target.removeAttribute(CSP_MEDIA_ATTR);',
-    // Remove onload listener when there are no longer styles that need to be loaded.
-    '    if (!document.head.querySelector(`link[${CSP_MEDIA_ATTR}]`)) {',
-    `      documentElement.removeEventListener('load', listener);`,
-    '    }',
-    '  };',
-    //  We use an event with capturing (the true parameter) because load events don't bubble.
-    `  documentElement.addEventListener('load', listener, true);`,
-    '})();',
-].join('\n');
-class CrittersExtended extends critters_1.default {
+const LINK_LOAD_SCRIPT_CONTENT = `
+(() => {
+  const CSP_MEDIA_ATTR = '${CSP_MEDIA_ATTR}';
+  const documentElement = document.documentElement;
+
+  // Listener for load events on link tags.
+  const listener = (e) => {
+    const target = e.target;
+    if (
+      !target ||
+      target.tagName !== 'LINK' ||
+      !target.hasAttribute(CSP_MEDIA_ATTR)
+    ) {
+      return;
+    }
+
+    target.media = target.getAttribute(CSP_MEDIA_ATTR);
+    target.removeAttribute(CSP_MEDIA_ATTR);
+
+    if (!document.head.querySelector(\`link[\${CSP_MEDIA_ATTR}]\`)) {
+      documentElement.removeEventListener('load', listener);
+    }
+  };
+
+  documentElement.addEventListener('load', listener, true);
+})();
+`.trim();
+class CrittersBase extends critters_1.default {
+}
+/* eslint-enable @typescript-eslint/no-unsafe-declaration-merging */
+class CrittersExtended extends CrittersBase {
     optionsExtended;
     warnings = [];
     errors = [];
-    initialEmbedLinkedStylesheet;
     addedCspScriptsDocuments = new WeakSet();
     documentNonces = new WeakMap();
     constructor(optionsExtended) {
@@ -71,17 +86,12 @@ class CrittersExtended extends critters_1.default {
             reduceInlineStyles: false,
             mergeStylesheets: false,
             // Note: if `preload` changes to anything other than `media`, the logic in
-            // `embedLinkedStylesheetOverride` will have to be updated.
+            // `embedLinkedStylesheet` will have to be updated.
             preload: 'media',
             noscriptFallback: true,
             inlineFonts: true,
         });
         this.optionsExtended = optionsExtended;
-        // We can't use inheritance to override `embedLinkedStylesheet`, because it's not declared in
-        // the `Critters` .d.ts which means that we can't call the `super` implementation. TS doesn't
-        // allow for `super` to be cast to a different type.
-        this.initialEmbedLinkedStylesheet = this.embedLinkedStylesheet;
-        this.embedLinkedStylesheet = this.embedLinkedStylesheetOverride;
     }
     readFile(path) {
         const readAsset = this.optionsExtended.readAsset;
@@ -91,7 +101,7 @@ class CrittersExtended extends critters_1.default {
      * Override of the Critters `embedLinkedStylesheet` method
      * that makes it work with Angular's CSP APIs.
      */
-    embedLinkedStylesheetOverride = async (link, document) => {
+    async embedLinkedStylesheet(link, document) {
         if (link.getAttribute('media') === 'print' && link.next?.name === 'noscript') {
             // Workaround for https://github.com/GoogleChromeLabs/critters/issues/64
             // NB: this is only needed for the webpack based builders.
@@ -102,7 +112,7 @@ class CrittersExtended extends critters_1.default {
                 link?.next?.remove();
             }
         }
-        const returnValue = await this.initialEmbedLinkedStylesheet(link, document);
+        const returnValue = await super.embedLinkedStylesheet(link, document);
         const cspNonce = this.findCspNonce(document);
         if (cspNonce) {
             const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);
@@ -126,7 +136,7 @@ class CrittersExtended extends critters_1.default {
             });
         }
         return returnValue;
-    };
+    }
     /**
      * Finds the CSP nonce for a specific document.
      */

package/src/utils/index-file/ngcm-attribute.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+/**
+ * Transforms the provided HTML by adding the `ngcm` attribute to the `<body>` tag.
+ * This is used in the client-side rendered (CSR) version of `index.html` to prevent hydration warnings.
+ *
+ * @param html The HTML markup to be transformed.
+ * @returns A promise that resolves to the transformed HTML string with the necessary modifications.
+ */
+export declare function addNgcmAttribute(html: string): Promise<string>;

package/src/utils/index-file/ngcm-attribute.js

@@ -0,0 +1,37 @@
+"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.addNgcmAttribute = addNgcmAttribute;
+const html_rewriting_stream_1 = require("./html-rewriting-stream");
+/**
+ * Defines a name of an attribute that is added to the `<body>` tag
+ * in the `index.html` file in case a given route was configured
+ * with `RenderMode.Client`. 'cm' is an abbreviation for "Client Mode".
+ *
+ * @see https://github.com/angular/angular/pull/58004
+ */
+const CLIENT_RENDER_MODE_FLAG = 'ngcm';
+/**
+ * Transforms the provided HTML by adding the `ngcm` attribute to the `<body>` tag.
+ * This is used in the client-side rendered (CSR) version of `index.html` to prevent hydration warnings.
+ *
+ * @param html The HTML markup to be transformed.
+ * @returns A promise that resolves to the transformed HTML string with the necessary modifications.
+ */
+async function addNgcmAttribute(html) {
+    const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(html);
+    rewriter.on('startTag', (tag) => {
+        if (tag.tagName === 'body' &&
+            !tag.attrs.some((attr) => attr.name === CLIENT_RENDER_MODE_FLAG)) {
+            tag.attrs.push({ name: CLIENT_RENDER_MODE_FLAG, value: '' });
+        }
+        rewriter.emitStartTag(tag);
+    });
+    return transformedContent();
+}

package/src/utils/index-file/valid-self-closing-tags.js

@@ -25,8 +25,36 @@ exports.VALID_SELF_CLOSING_TAGS = new Set([
     'track',
     'wbr',
     /** SVG tags */
+    'animate',
+    'animateMotion',
+    'animateTransform',
     'circle',
     'ellipse',
+    'feBlend',
+    'feColorMatrix',
+    'feComponentTransfer',
+    'feComposite',
+    'feConvolveMatrix',
+    'feDiffuseLighting',
+    'feDisplacementMap',
+    'feDistantLight',
+    'feDropShadow',
+    'feFlood',
+    'feFuncA',
+    'feFuncB',
+    'feFuncG',
+    'feFuncR',
+    'feGaussianBlur',
+    'feImage',
+    'feMerge',
+    'feMergeNode',
+    'feMorphology',
+    'feOffset',
+    'fePointLight',
+    'feSpecularLighting',
+    'feSpotLight',
+    'feTile',
+    'feTurbulence',
     'line',
     'path',
     'polygon',

package/src/utils/normalize-cache.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeCacheOptions = normalizeCacheOptions;
 const node_path_1 = require("node:path");
 /** Version placeholder is replaced during the build process with actual package version */
-const VERSION = '19.0.0-next.0';
+const VERSION = '19.0.0-next.10';
 function hasCacheMetadata(value) {
     return (!!value &&
         typeof value === 'object' &&

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

@@ -5,4 +5,4 @@
  * 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 function patchFetchToLoadInMemoryAssets(): void;
+export declare function patchFetchToLoadInMemoryAssets(baseURL: URL): void;

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

@@ -17,8 +17,7 @@ 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() {
+function patchFetchToLoadInMemoryAssets(baseURL) {
     const originalFetch = globalThis.fetch;
     const patchedFetch = async (input, init) => {
         let url;
@@ -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 !== baseURL.hostname || !assetFiles[pathname]) {
             // Only handle relative requests or files that are in assets.
             return originalFetch(input, init);
         }

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * @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';
+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.
+ *
+ * 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.
+ * @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, perenderedRoutes?: PrerenderedRoutesRecord | 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.
+ * @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, locale: string | undefined): string;

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

@@ -0,0 +1,126 @@
+"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_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.
+ *
+ * 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.
+ * @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, perenderedRoutes = {}) {
+    const entryPointsContent = [];
+    if (i18nOptions.shouldInline) {
+        for (const locale of i18nOptions.inlineLocales) {
+            const importPath = './' + (i18nOptions.flatOutput ? '' : locale + '/') + MAIN_SERVER_OUTPUT_FILENAME;
+            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}')]`);
+    }
+    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 = `
+export default {
+  basePath: '${baseHref ?? '/'}',
+  entryPoints: new Map([${entryPointsContent.join(', \n')}]),
+  staticPathsHeaders: new Map([${staticHeaders.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.
+ * @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, 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 () => \`${escapeUnsafeChars(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')}]),
+  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,19 +5,35 @@
  * 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';
-interface PrerenderOptions {
-    routesFile?: string;
-    discoverRoutes?: boolean;
-}
-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>;
+import { SerializableRouteTreeNode } from './models';
+type PrerenderOptions = NormalizedApplicationBuildOptions['prerenderOptions'];
+type AppShellOptions = NormalizedApplicationBuildOptions['appShellOptions'];
+/**
+ * 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[]>, outputMode: OutputMode | undefined, sourcemap?: boolean, maxThreads?: number): Promise<{
+    output: PrerenderOutput;
     warnings: string[];
     errors: string[];
-    prerenderedRoutes: Set<string>;
+    serializableRouteTreeNode: SerializableRouteTreeNode;
 }>;
 export {};