@angular/ssr 19.0.0-next.0 → 19.0.0-next.1

package/esm2022/private_export.mjs

@@ -0,0 +1,10 @@
+/**
+ * @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 { getRoutesFromAngularRouterConfig as ɵgetRoutesFromAngularRouterConfig } from './src/routes/ng-routes';
+export { ServerRenderContext as ɵServerRenderContext, getOrCreateAngularServerApp as ɵgetOrCreateAngularServerApp, destroyAngularServerApp as ɵdestroyAngularServerApp, } from './src/app';
+export { setAngularAppManifest as ɵsetAngularAppManifest, setAngularAppEngineManifest as ɵsetAngularAppEngineManifest, } from './src/manifest';

package/esm2022/public_api.mjs

@@ -6,4 +6,4 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 export { CommonEngine, } from './src/common-engine/common-engine';
-export { getRoutesFromAngularRouterConfig as ɵgetRoutesFromAngularRouterConfig } from './src/routes/ng-routes';
+export * from './private_export';

package/esm2022/src/app-engine.mjs

@@ -16,38 +16,30 @@ import { getAngularAppEngineManifest } from './manifest';
 export class AngularAppEngine {
     /**
      * Hooks for extending or modifying the behavior of the server application.
-     * @internal This property is accessed by the Angular CLI when running the dev-server.
+     * These hooks are used by the Angular CLI when running the development server and
+     * provide extensibility points for the application lifecycle.
+     *
+     * @internal
      */
     static hooks = new Hooks();
     /**
-     * Hooks for extending or modifying the behavior of the server application.
-     * This instance can be used to attach custom functionality to various events in the server application lifecycle.
+     * Provides access to the hooks for extending or modifying the server application's behavior.
+     * This allows attaching custom functionality to various server application lifecycle events.
+     *
      * @internal
      */
     get hooks() {
         return AngularAppEngine.hooks;
     }
-    /**
-     * Specifies if the application is operating in development mode.
-     * This property controls the activation of features intended for production, such as caching mechanisms.
-     * @internal
-     */
-    static isDevMode = false;
     /**
      * The manifest for the server application.
      */
     manifest = getAngularAppEngineManifest();
     /**
-     * Map of locale strings to corresponding `AngularServerApp` instances.
-     * Each instance represents an Angular server application.
-     */
-    appsCache = new Map();
-    /**
-     * Renders an HTTP request using the appropriate Angular server application and returns a response.
+     * Renders a response for the given HTTP request using the server application.
      *
-     * This method determines the entry point for the Angular server application based on the request URL,
-     * and caches the server application instances for reuse. If the application is in development mode,
-     * the cache is bypassed and a new instance is created for each request.
+     * This method processes the request, determines the appropriate route and rendering context,
+     * and returns an HTTP response.
      *
      * If the request URL appears to be for a file (excluding `/index.html`), the method returns `null`.
      * A request to `https://www.example.com/page/index.html` will render the Angular route
@@ -65,18 +57,9 @@ export class AngularAppEngine {
         if (!entryPoint) {
             return null;
         }
-        const [locale, loadModule] = entryPoint;
-        let serverApp = this.appsCache.get(locale);
-        if (!serverApp) {
-            const { AngularServerApp } = await loadModule();
-            serverApp = new AngularServerApp({
-                isDevMode: AngularAppEngine.isDevMode,
-                hooks: this.hooks,
-            });
-            if (!AngularAppEngine.isDevMode) {
-                this.appsCache.set(locale, serverApp);
-            }
-        }
+        const { ɵgetOrCreateAngularServerApp: getOrCreateAngularServerApp } = await entryPoint();
+        const serverApp = getOrCreateAngularServerApp();
+        serverApp.hooks = this.hooks;
         return serverApp.render(request, requestContext);
     }
     /**
@@ -86,21 +69,16 @@ export class AngularAppEngine {
      * If there is only one entry point available, it is returned regardless of the URL.
      * Otherwise, the method extracts a potential locale identifier from the URL and looks up the corresponding entry point.
      *
-     * @param url - The URL used to derive the locale and determine the entry point.
-     * @returns An array containing:
-     * - The first element is the locale extracted from the URL.
-     * - The second element is a function that returns a promise resolving to an object with the `AngularServerApp` type.
-     *
-     * Returns `null` if no matching entry point is found for the extracted locale.
+     * @param url - The URL used to derive the locale and determine the appropriate entry point.
+     * @returns A function that returns a promise resolving to an object with the `EntryPointExports` type,
+     * or `undefined` if no matching entry point is found for the extracted locale.
      */
     getEntryPointFromUrl(url) {
-        // Find bundle for locale
         const { entryPoints, basePath } = this.manifest;
         if (entryPoints.size === 1) {
-            return entryPoints.entries().next().value;
+            return entryPoints.values().next().value;
         }
         const potentialLocale = getPotentialLocaleIdFromUrl(url, basePath);
-        const entryPoint = entryPoints.get(potentialLocale);
-        return entryPoint ? [potentialLocale, entryPoint] : null;
+        return entryPoints.get(potentialLocale);
     }
 }

package/esm2022/src/app.mjs

@@ -5,56 +5,47 @@
  * 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 { ɵConsole, ɵresetCompiledComponents } from '@angular/core';
+import { ɵSERVER_CONTEXT as SERVER_CONTEXT } from '@angular/platform-server';
 import { ServerAssets } from './assets';
+import { Console } from './console';
 import { Hooks } from './hooks';
 import { getAngularAppManifest } from './manifest';
-import { ServerRenderContext, render } from './render';
 import { ServerRouter } from './routes/router';
+import { REQUEST, REQUEST_CONTEXT, RESPONSE_INIT } from './tokens';
+import { renderAngular } from './utils/ng';
+/**
+ * Enum representing the different contexts in which server rendering can occur.
+ */
+export var ServerRenderContext;
+(function (ServerRenderContext) {
+    ServerRenderContext["SSR"] = "ssr";
+    ServerRenderContext["SSG"] = "ssg";
+    ServerRenderContext["AppShell"] = "app-shell";
+})(ServerRenderContext || (ServerRenderContext = {}));
 /**
  * Represents a locale-specific Angular server application managed by the server application engine.
  *
  * The `AngularServerApp` class handles server-side rendering and asset management for a specific locale.
  */
 export class AngularServerApp {
-    options;
-    /**
-     * The manifest associated with this server application.
-     * @internal
-     */
-    manifest = getAngularAppManifest();
     /**
      * Hooks for extending or modifying the behavior of the server application.
      * This instance can be used to attach custom functionality to various events in the server application lifecycle.
-     * @internal
      */
-    hooks;
+    hooks = new Hooks();
     /**
-     * Specifies if the server application is operating in development mode.
-     * This property controls the activation of features intended for production, such as caching mechanisms.
-     * @internal
+     * The manifest associated with this server application.
      */
-    isDevMode;
+    manifest = getAngularAppManifest();
     /**
      * An instance of ServerAsset that handles server-side asset.
-     * @internal
      */
     assets = new ServerAssets(this.manifest);
     /**
      * The router instance used for route matching and handling.
      */
     router;
-    /**
-     * Creates a new `AngularServerApp` instance with the provided configuration options.
-     *
-     * @param options - The configuration options for the server application.
-     * - `isDevMode`: Flag indicating if the application is in development mode.
-     * - `hooks`: Optional hooks for customizing application behavior.
-     */
-    constructor(options) {
-        this.options = options;
-        this.isDevMode = options.isDevMode ?? false;
-        this.hooks = options.hooks ?? new Hooks();
-    }
     /**
      * Renders a response for the given HTTP request using the server application.
      *
@@ -66,7 +57,38 @@ export class AngularServerApp {
      *
      * @returns A promise that resolves to the HTTP response object resulting from the rendering, or null if no match is found.
      */
-    async render(request, requestContext, serverContext = ServerRenderContext.SSR) {
+    render(request, requestContext, serverContext = ServerRenderContext.SSR) {
+        return Promise.race([
+            this.createAbortPromise(request),
+            this.handleRendering(request, requestContext, serverContext),
+        ]);
+    }
+    /**
+     * Creates a promise that rejects when the request is aborted.
+     *
+     * @param request - The HTTP request to monitor for abortion.
+     * @returns A promise that never resolves but rejects with an `AbortError` if the request is aborted.
+     */
+    createAbortPromise(request) {
+        return new Promise((_, reject) => {
+            request.signal.addEventListener('abort', () => {
+                const abortError = new Error(`Request for: ${request.url} was aborted.\n${request.signal.reason}`);
+                abortError.name = 'AbortError';
+                reject(abortError);
+            }, { once: true });
+        });
+    }
+    /**
+     * Handles the server-side rendering process for the given HTTP request.
+     * This method matches the request URL to a route and performs rendering if a matching route is found.
+     *
+     * @param request - The incoming HTTP request to be processed.
+     * @param requestContext - Optional additional context for rendering, such as request metadata.
+     * @param serverContext - The rendering context. Defaults to server-side rendering (SSR).
+     *
+     * @returns A promise that resolves to the rendered response, or null if no matching route is found.
+     */
+    async handleRendering(request, requestContext, serverContext = ServerRenderContext.SSR) {
         const url = new URL(request.url);
         this.router ??= await ServerRouter.from(this.manifest, url);
         const matchedRoute = this.router.match(url);
@@ -80,6 +102,66 @@ export class AngularServerApp {
             // See: https://developer.mozilla.org/en-US/docs/Web/API/Response/redirect_static#status
             return Response.redirect(new URL(redirectTo, url), 302);
         }
-        return render(this, request, serverContext, requestContext);
+        const platformProviders = [
+            {
+                provide: SERVER_CONTEXT,
+                useValue: serverContext,
+            },
+            {
+                // An Angular Console Provider that does not print a set of predefined logs.
+                provide: ɵConsole,
+                // Using `useClass` would necessitate decorating `Console` with `@Injectable`,
+                // which would require switching from `ts_library` to `ng_module`. This change
+                // would also necessitate various patches of `@angular/bazel` to support ESM.
+                useFactory: () => new Console(),
+            },
+        ];
+        const isSsrMode = serverContext === ServerRenderContext.SSR;
+        const responseInit = {};
+        if (isSsrMode) {
+            platformProviders.push({
+                provide: REQUEST,
+                useValue: request,
+            }, {
+                provide: REQUEST_CONTEXT,
+                useValue: requestContext,
+            }, {
+                provide: RESPONSE_INIT,
+                useValue: responseInit,
+            });
+        }
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            // Need to clean up GENERATED_COMP_IDS map in `@angular/core`.
+            // Otherwise an incorrect component ID generation collision detected warning will be displayed in development.
+            // See: https://github.com/angular/angular-cli/issues/25924
+            ɵresetCompiledComponents();
+        }
+        const { manifest, hooks, assets } = this;
+        let html = await assets.getIndexServerHtml();
+        // Skip extra microtask if there are no pre hooks.
+        if (hooks.has('html:transform:pre')) {
+            html = await hooks.run('html:transform:pre', { html });
+        }
+        return new Response(await renderAngular(html, manifest.bootstrap(), new URL(request.url), platformProviders), responseInit);
     }
 }
+let angularServerApp;
+/**
+ * Retrieves or creates an instance of `AngularServerApp`.
+ * - If an instance of `AngularServerApp` already exists, it will return the existing one.
+ * - If no instance exists, it will create a new one with the provided options.
+ * @returns The existing or newly created instance of `AngularServerApp`.
+ */
+export function getOrCreateAngularServerApp() {
+    return (angularServerApp ??= new AngularServerApp());
+}
+/**
+ * Destroys the existing `AngularServerApp` instance, releasing associated resources and resetting the
+ * reference to `undefined`.
+ *
+ * This function is primarily used to enable the recreation of the `AngularServerApp` instance,
+ * typically when server configuration or application state needs to be refreshed.
+ */
+export function destroyAngularServerApp() {
+    angularServerApp = undefined;
+}

package/esm2022/src/assets.mjs

@@ -26,7 +26,7 @@ export class ServerAssets {
      * @throws Error If the asset path is not found in the manifest, an error is thrown.
      */
     async getServerAsset(path) {
-        const asset = this.manifest.assets[path];
+        const asset = this.manifest.assets.get(path);
         if (!asset) {
             throw new Error(`Server asset '${path}' does not exist.`);
         }

package/esm2022/src/routes/ng-routes.mjs

@@ -95,10 +95,12 @@ function resolveRedirectTo(routePath, redirectTo) {
  * @returns A promise that resolves to an object of type `AngularRouterConfigResult`.
  */
 export async function getRoutesFromAngularRouterConfig(bootstrap, document, url) {
-    // Need to clean up GENERATED_COMP_IDS map in `@angular/core`.
-    // Otherwise an incorrect component ID generation collision detected warning will be displayed in development.
-    // See: https://github.com/angular/angular-cli/issues/25924
-    ɵresetCompiledComponents();
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        // Need to clean up GENERATED_COMP_IDS map in `@angular/core`.
+        // Otherwise an incorrect component ID generation collision detected warning will be displayed in development.
+        // See: https://github.com/angular/angular-cli/issues/25924
+        ɵresetCompiledComponents();
+    }
     const { protocol, host } = url;
     // Create and initialize the Angular platform for server-side rendering.
     const platformRef = createPlatformFactory(platformCore, 'server', [