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

package/index.d.ts

@@ -1,6 +1,7 @@
 import type { ApplicationRef } from '@angular/core';
 import { default as default_2 } from 'critters';
 import { EnvironmentProviders } from '@angular/core';
+import { InjectionToken } from '@angular/core';
 import type { Type } from '@angular/core';
 
 /**
@@ -26,6 +27,10 @@ export declare class AngularAppEngine {
      * The manifest for the server application.
      */
     private readonly manifest;
+    /**
+     * A cache that holds entry points, keyed by their potential locale string.
+     */
+    private readonly entryPointsCache;
     /**
      * Renders a response for the given HTTP request using the server application.
      *
@@ -42,18 +47,6 @@ export declare class AngularAppEngine {
      * rather than an application route.
      */
     render(request: Request, requestContext?: unknown): Promise<Response | null>;
-    /**
-     * Retrieves the entry point path and locale for the Angular server application based on the provided URL.
-     *
-     * This method determines the appropriate entry point and locale for rendering the application by examining the URL.
-     * 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 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.
-     */
-    private getEntryPointFromUrl;
     /**
      * Retrieves HTTP headers for a request associated with statically generated (SSG) pages,
      * based on the URL pathname.
@@ -63,6 +56,25 @@ export declare class AngularAppEngine {
      * @note This function should be used exclusively for retrieving headers of SSG pages.
      */
     getPrerenderHeaders(request: Request): ReadonlyMap<string, string>;
+    /**
+     * Retrieves the exports for a specific entry point, caching the result.
+     *
+     * @param potentialLocale - The locale string used to find the corresponding entry point.
+     * @returns A promise that resolves to the entry point exports or `undefined` if not found.
+     */
+    private getEntryPointExports;
+    /**
+     * Retrieves the entry point for a given URL by determining the locale and mapping it to
+     * the appropriate application bundle.
+     *
+     * This method determines the appropriate entry point and locale for rendering the application by examining the URL.
+     * 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 of the request.
+     * @returns A promise that resolves to the entry point exports or `undefined` if not found.
+     */
+    private getEntryPointExportsForUrl;
 }
 
 /**
@@ -120,6 +132,11 @@ declare interface AngularAppManifest {
      * It is used for route matching and navigation within the server application.
      */
     readonly routes?: SerializableRouteTreeNode;
+    /**
+     * An optional string representing the locale or language code to be used for
+     * the application, aiding with localization and rendering content specific to the locale.
+     */
+    readonly locale?: string;
 }
 
 /**
@@ -192,6 +209,14 @@ declare class AngularServerApp {
      * The bootstrap mechanism for the server application.
      */
     private boostrap;
+    /**
+     * Cache for storing critical CSS for pages.
+     * Stores a maximum of MAX_INLINE_CSS_CACHE_ENTRIES entries.
+     *
+     * Uses an LRU (Least Recently Used) eviction policy, meaning that when the cache is full,
+     * the least recently accessed page's critical CSS will be removed to make space for new entries.
+     */
+    private readonly criticalCssLRUCache;
     /**
      * Renders a response for the given HTTP request using the server application.
      *
@@ -233,6 +258,31 @@ declare class AngularServerApp {
     private handleRendering;
 }
 
+/**
+ * Annotates a request handler function with metadata, marking it as a special
+ * handler.
+ *
+ * @param handler - The request handler function to be annotated.
+ * @returns The same handler function passed in, with metadata attached.
+ *
+ * @example
+ * Example usage in a Hono application:
+ * ```ts
+ * const app = new Hono();
+ * export default createRequestHandler(app.fetch);
+ * ```
+ *
+ * @example
+ * Example usage in a H3 application:
+ * ```ts
+ * const app = createApp();
+ * const handler = toWebHandler(app);
+ * export default createRequestHandler(handler);
+ * ```
+ * @developerPreview
+ */
+export declare function createRequestHandler(handler: RequestHandlerFunction): RequestHandlerFunction;
+
 declare interface CrittersBase {
     embedLinkedStylesheet(link: PartialHTMLElement, document: PartialDocument): Promise<unknown>;
 }
@@ -310,13 +360,14 @@ declare interface HooksMapping {
 
 
 /**
- * Handler function type for HTML transformation hooks.
- * It takes an object containing the HTML content to be modified.
+ * Defines a handler function type for transforming HTML content.
+ * This function receives an object with the HTML to be processed.
  *
- * @param ctx - The context object containing the HTML content.
- * @returns The modified HTML content or a promise that resolves to the modified HTML content.
+ * @param ctx - An object containing the URL and HTML content to be transformed.
+ * @returns The transformed HTML as a string or a promise that resolves to the transformed HTML.
  */
 declare type HtmlTransformHandler = (ctx: {
+    url: URL;
     html: string;
 }) => string | Promise<string>;
 
@@ -392,6 +443,34 @@ export declare enum RenderMode {
     Prerender = 3
 }
 
+/**
+ * Injection token for the current request.
+ * @developerPreview
+ */
+export declare const REQUEST: InjectionToken<Request>;
+
+/**
+ * Injection token for additional request context.
+ * @developerPreview
+ */
+export declare const REQUEST_CONTEXT: InjectionToken<unknown>;
+
+
+/**
+ * Function for handling HTTP requests in a web environment.
+ *
+ * @param request - The incoming HTTP request object.
+ * @returns A Promise resolving to a `Response` object, `null`, or directly a `Response`,
+ * supporting both synchronous and asynchronous handling.
+ */
+declare type RequestHandlerFunction = (request: Request) => Promise<Response | null> | null | Response;
+
+/**
+ * Injection token for the response initialization options.
+ * @developerPreview
+ */
+export declare const RESPONSE_INIT: InjectionToken<ResponseInit>;
+
 /**
  * A route tree implementation that supports efficient route matching, including support for wildcard routes.
  * This structure is useful for organizing and retrieving routes in a hierarchical manner,
@@ -455,7 +534,7 @@ declare class RouteTree<AdditionalMetadata extends Record<string, unknown> = {}>
      *
      * @param node - The current node to start the traversal from. Defaults to the root node of the tree.
      */
-    private traverse;
+    traverse(node?: RouteTreeNode<AdditionalMetadata>): Generator<RouteTreeNodeMetadata & AdditionalMetadata>;
     /**
      * Extracts the path segments from a given route string.
      *
@@ -495,6 +574,35 @@ declare class RouteTree<AdditionalMetadata extends Record<string, unknown> = {}>
     private createEmptyRouteTreeNode;
 }
 
+/**
+ * Represents a node within the route tree structure.
+ * Each node corresponds to a route segment and may have associated metadata and child nodes.
+ * The `AdditionalMetadata` type parameter allows for extending the node metadata with custom data.
+ */
+declare interface RouteTreeNode<AdditionalMetadata extends Record<string, unknown>> {
+    /**
+     * The segment value associated with this node.
+     * A segment is a single part of a route path, typically delimited by slashes (`/`).
+     * For example, in the route `/users/:id/profile`, the segments are `users`, `:id`, and `profile`.
+     * Segments can also be wildcards (`*`), which match any segment in that position of the route.
+     */
+    segment: string;
+    /**
+     * The index indicating the order in which the route was inserted into the tree.
+     * This index helps determine the priority of routes during matching, with lower indexes
+     * indicating earlier inserted routes.
+     */
+    insertionIndex: number;
+    /**
+     * A map of child nodes, keyed by their corresponding route segment or wildcard.
+     */
+    children: Map<string, RouteTreeNode<AdditionalMetadata>>;
+    /**
+     * Optional metadata associated with this node, providing additional information such as redirects.
+     */
+    metadata?: RouteTreeNodeMetadata & AdditionalMetadata;
+}
+
 /**
  * Describes metadata associated with a node in the route tree.
  * This metadata includes information such as the route path and optional redirect instructions.

package/node/index.d.ts

@@ -109,6 +109,52 @@ export declare interface CommonEngineRenderOptions {
     publicPath?: string;
 }
 
+/**
+ * Attaches metadata to the handler function to mark it as a special handler for Node.js environments.
+ *
+ * @typeParam T - The type of the handler function.
+ * @param handler - The handler function to be defined and annotated.
+ * @returns The same handler function passed as an argument, with metadata attached.
+ *
+ * @example
+ * Usage in an Express application:
+ * ```ts
+ * const app = express();
+ * export default createNodeRequestHandler(app);
+ * ```
+ *
+ * @example
+ * Usage in a Hono application:
+ * ```ts
+ * const app = new Hono();
+ * export default createNodeRequestHandler(async (req, res, next) => {
+ *   try {
+ *     const webRes = await app.fetch(createWebRequestFromNodeRequest(req));
+ *     if (webRes) {
+ *       await writeResponseToNodeResponse(webRes, res);
+ *     } else {
+ *       next();
+ *     }
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * }));
+ * ```
+ *
+ * @example
+ * Usage in a Fastify application:
+ * ```ts
+ * const app = Fastify();
+ * export default createNodeRequestHandler(async (req, res) => {
+ *   await app.ready();
+ *   app.server.emit('request', req, res);
+ *   res.send('Hello from Fastify with Node Next Handler!');
+ * }));
+ * ```
+ * @developerPreview
+ */
+export declare function createNodeRequestHandler<T extends RequestHandlerFunction>(handler: T): T;
+
 /**
  * Converts a Node.js `IncomingMessage` into a Web Standard `Request`.
  *
@@ -137,6 +183,17 @@ export declare function createWebRequestFromNodeRequest(nodeRequest: IncomingMes
  */
 export declare function isMainModule(url: string): boolean;
 
+/**
+ * Represents a middleware function for handling HTTP requests in a Node.js environment.
+ *
+ * @param req - The incoming HTTP request object.
+ * @param res - The outgoing HTTP response object.
+ * @param next - A callback function that signals the completion of the middleware or forwards the error if provided.
+ *
+ * @returns A Promise that resolves to void or simply void. The handler can be asynchronous.
+ */
+declare type RequestHandlerFunction = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void> | void;
+
 /**
  * Streams a web-standard `Response` into a Node.js `ServerResponse`.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/ssr",
-  "version": "19.0.0-next.7",
+  "version": "19.0.0-next.9",
   "description": "Angular server side rendering utilities",
   "license": "MIT",
   "homepage": "https://github.com/angular/angular-cli",
@@ -22,12 +22,12 @@
     "@angular/router": "^19.0.0-next.0"
   },
   "devDependencies": {
-    "@angular/common": "19.0.0-next.6",
-    "@angular/compiler": "19.0.0-next.6",
-    "@angular/core": "19.0.0-next.6",
-    "@angular/platform-browser": "19.0.0-next.6",
-    "@angular/platform-server": "19.0.0-next.6",
-    "@angular/router": "19.0.0-next.6",
+    "@angular/common": "19.0.0-next.7",
+    "@angular/compiler": "19.0.0-next.7",
+    "@angular/core": "19.0.0-next.7",
+    "@angular/platform-browser": "19.0.0-next.7",
+    "@angular/platform-server": "19.0.0-next.7",
+    "@angular/router": "19.0.0-next.7",
     "@bazel/runfiles": "^5.8.1"
   },
   "schematics": "./schematics/collection.json",