@angular/ssr 19.0.5 → 19.1.0-next.1

package/index.d.ts

@@ -36,9 +36,9 @@ export declare class AngularAppEngine {
      */
     private readonly manifest;
     /**
-     * The number of entry points available in the server application's manifest.
+     * A map of supported locales from the server application's manifest.
      */
-    private readonly entryPointsCount;
+    private readonly supportedLocales;
     /**
      * A cache that holds entry points, keyed by their potential locale string.
      */
@@ -55,6 +55,15 @@ export declare class AngularAppEngine {
      * corresponding to `https://www.example.com/page`.
      */
     handle(request: Request, requestContext?: unknown): Promise<Response | null>;
+    /**
+     * Handles requests for the base path when i18n is enabled.
+     * Redirects the user to a locale-specific path based on the `Accept-Language` header.
+     *
+     * @param request The incoming request.
+     * @returns A `Response` object with a 302 redirect, or `null` if i18n is not enabled
+     *          or the request is not for the base path.
+     */
+    private redirectBasedOnAcceptLanguage;
     /**
      * Retrieves the Angular server application instance for a given request.
      *
@@ -95,7 +104,7 @@ declare interface AngularAppEngineManifest {
     /**
      * A readonly record of entry points for the server application.
      * Each entry consists of:
-     * - `key`: The base href for the entry point.
+     * - `key`: The url segment for the entry point.
      * - `value`: A function that returns a promise resolving to an object of type `EntryPointExports`.
      */
     readonly entryPoints: Readonly<Record<string, (() => Promise<EntryPointExports>) | undefined>>;
@@ -104,6 +113,13 @@ declare interface AngularAppEngineManifest {
      * This is used to determine the root path of the application.
      */
     readonly basePath: string;
+    /**
+     * A readonly record mapping supported locales to their respective entry-point paths.
+     * Each entry consists of:
+     * - `key`: The locale identifier (e.g., 'en', 'fr').
+     * - `value`: The url segment associated with that locale.
+     */
+    readonly supportedLocales: Readonly<Record<string, string | undefined>>;
 }
 
 /**
@@ -144,6 +160,26 @@ declare interface AngularAppManifest {
      * the application, aiding with localization and rendering content specific to the locale.
      */
     readonly locale?: string;
+    /**
+     * Maps entry-point names to their corresponding browser bundles and loading strategies.
+     *
+     * - **Key**: The entry-point name, typically the value of `ɵentryName`.
+     * - **Value**: An array of objects, each representing a browser bundle with:
+     *   - `path`: The filename or URL of the associated JavaScript bundle to preload.
+     *   - `dynamicImport`: A boolean indicating whether the bundle is loaded via a dynamic `import()`.
+     *     If `true`, the bundle is lazily loaded, impacting its preloading behavior.
+     *
+     * ### Example
+     * ```ts
+     * {
+     *   'src/app/lazy/lazy.ts': [{ path: 'src/app/lazy/lazy.js', dynamicImport: true }]
+     * }
+     * ```
+     */
+    readonly entryPointToBrowserMapping?: Readonly<Record<string, ReadonlyArray<{
+        path: string;
+        dynamicImport: boolean;
+    }> | undefined>>;
 }
 
 /**
@@ -293,6 +329,7 @@ declare class AngularServerApp {
      *
      * @param html - The raw HTML content to be transformed.
      * @param url - The URL associated with the HTML content, used for context during transformations.
+     * @param preload - An array of URLs representing the JavaScript resources to preload.
      * @returns A promise that resolves to the transformed HTML string.
      */
     private runTransformsOnHtml;
@@ -369,6 +406,8 @@ declare interface EntryPointExports {
     ɵdestroyAngularServerApp: () => void;
 }
 
+declare type EntryPointToBrowserMapping = AngularAppManifest['entryPointToBrowserMapping'];
+
 /**
  * Defines the names of available hooks for registering and triggering custom logic within the application.
  */
@@ -698,6 +737,10 @@ declare interface RouteTreeNodeMetadata {
      * Specifies the rendering mode used for this route.
      */
     renderMode: RenderMode;
+    /**
+     * A list of resource that should be preloaded by the browser.
+     */
+    preload?: readonly string[];
 }
 
 /**
@@ -918,10 +961,11 @@ export declare function ɵgetOrCreateAngularServerApp(options?: Readonly<Angular
  * @param invokeGetPrerenderParams - A boolean flag indicating whether to invoke `getPrerenderParams` for parameterized SSG routes
  * to handle prerendering paths. Defaults to `false`.
  * @param includePrerenderFallbackRoutes - A flag indicating whether to include fallback routes in the result. Defaults to `true`.
+ * @param entryPointToBrowserMapping - Maps the entry-point name to the associated JavaScript browser bundles.
  *
  * @returns A promise that resolves to an object of type `AngularRouterConfigResult` or errors.
  */
-export declare function ɵgetRoutesFromAngularRouterConfig(bootstrap: AngularBootstrap, document: string, url: URL, invokeGetPrerenderParams?: boolean, includePrerenderFallbackRoutes?: boolean): Promise<AngularRouterConfigResult>;
+export declare function ɵgetRoutesFromAngularRouterConfig(bootstrap: AngularBootstrap, document: string, url: URL, invokeGetPrerenderParams?: boolean, includePrerenderFallbackRoutes?: boolean, entryPointToBrowserMapping?: EntryPointToBrowserMapping | undefined): Promise<AngularRouterConfigResult>;
 
 export declare class ɵInlineCriticalCssProcessor extends BeastiesBase {
     readFile: (path: string) => Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/ssr",
-  "version": "19.0.5",
+  "version": "19.1.0-next.1",
   "description": "Angular server side rendering utilities",
   "license": "MIT",
   "homepage": "https://github.com/angular/angular-cli",
@@ -16,18 +16,23 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "^19.0.0",
-    "@angular/core": "^19.0.0",
-    "@angular/platform-server": "^19.0.0",
-    "@angular/router": "^19.0.0"
+    "@angular/common": "^19.0.0 || ^19.1.0-next.0",
+    "@angular/core": "^19.0.0 || ^19.1.0-next.0",
+    "@angular/platform-server": "^19.0.0 || ^19.1.0-next.0",
+    "@angular/router": "^19.0.0 || ^19.1.0-next.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/platform-server": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@angular/common": "19.0.0",
-    "@angular/compiler": "19.0.0",
-    "@angular/core": "19.0.0",
-    "@angular/platform-browser": "19.0.0",
-    "@angular/platform-server": "19.0.0",
-    "@angular/router": "19.0.0",
+    "@angular/common": "19.1.0-next.2",
+    "@angular/compiler": "19.1.0-next.2",
+    "@angular/core": "19.1.0-next.2",
+    "@angular/platform-browser": "19.1.0-next.2",
+    "@angular/platform-server": "19.1.0-next.2",
+    "@angular/router": "19.1.0-next.2",
     "@bazel/runfiles": "^5.8.1"
   },
   "sideEffects": false,

package/third_party/beasties/index.js

@@ -2003,26 +2003,39 @@ var hasRequiredNonSecure;
 function requireNonSecure () {
 	if (hasRequiredNonSecure) return nonSecure;
 	hasRequiredNonSecure = 1;
+	// This alphabet uses `A-Za-z0-9_-` symbols.
+	// The order of characters is optimized for better gzip and brotli compression.
+	// References to the same file (works both for gzip and brotli):
+	// `'use`, `andom`, and `rict'`
+	// References to the brotli default dictionary:
+	// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
 	let urlAlphabet =
 	  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
 	let customAlphabet = (alphabet, defaultSize = 21) => {
 	  return (size = defaultSize) => {
 	    let id = '';
-	    let i = size;
+	    // A compact alternative for `for (var i = 0; i < step; i++)`.
+	    let i = size | 0;
 	    while (i--) {
+	      // `| 0` is more compact and faster than `Math.floor()`.
 	      id += alphabet[(Math.random() * alphabet.length) | 0];
 	    }
 	    return id
 	  }
 	};
+
 	let nanoid = (size = 21) => {
 	  let id = '';
-	  let i = size;
+	  // A compact alternative for `for (var i = 0; i < step; i++)`.
+	  let i = size | 0;
 	  while (i--) {
+	    // `| 0` is more compact and faster than `Math.floor()`.
 	    id += urlAlphabet[(Math.random() * 64) | 0];
 	  }
 	  return id
 	};
+
 	nonSecure = { nanoid, customAlphabet };
 	return nonSecure;
 }
@@ -10951,36 +10964,43 @@ function parseStylesheet(stylesheet) {
   return parse$2(stylesheet);
 }
 function serializeStylesheet(ast, options) {
-  let cssStr = "";
+  const cssParts = [];
   stringify(ast, (result, node, type) => {
     if (node?.type === "decl" && node.value.includes("</style>")) {
       return;
     }
     if (!options.compress) {
-      cssStr += result;
+      cssParts.push(result);
       return;
     }
     if (node?.type === "comment")
       return;
     if (node?.type === "decl") {
       const prefix = node.prop + node.raws.between;
-      cssStr += result.replace(prefix, prefix.trim());
+      cssParts.push(result.replace(prefix, prefix.trim()));
       return;
     }
     if (type === "start") {
       if (node?.type === "rule" && node.selectors) {
-        cssStr += `${node.selectors.join(",")}{`;
+        if (node.selectors.length === 1) {
+          cssParts.push(node.selectors[0] ?? "", "{");
+        } else {
+          cssParts.push(node.selectors.join(","), "{");
+        }
       } else {
-        cssStr += result.replace(/\s\{$/, "{");
+        cssParts.push(result.trim());
       }
       return;
     }
     if (type === "end" && result === "}" && node?.raws?.semicolon) {
-      cssStr = cssStr.slice(0, -1);
+      const lastItemIdx = cssParts.length - 2;
+      if (lastItemIdx >= 0 && cssParts[lastItemIdx]) {
+        cssParts[lastItemIdx] = cssParts[lastItemIdx].slice(0, -1);
+      }
     }
-    cssStr += result.trim();
+    cssParts.push(result.trim());
   });
-  return cssStr;
+  return cssParts.join("");
 }
 function markOnly(predicate) {
   return (rule) => {
@@ -11163,7 +11183,7 @@ function extendElement(element) {
         return this.getAttribute("id");
       },
       set(value) {
-        this.setAttribue("id", value);
+        this.setAttribute("id", value);
       }
     },
     className: {
@@ -11323,21 +11343,40 @@ function extendDocument(document) {
     }
   });
 }
+const selectorTokensCache = /* @__PURE__ */ new Map();
 function cachedQuerySelector(sel, node) {
-  const selectorTokens = parse$1(sel);
-  for (const tokens of selectorTokens) {
-    if (tokens.length === 1) {
-      const token = tokens[0];
-      if (token.type === "attribute" && token.name === "class") {
+  let selectorTokens = selectorTokensCache.get(sel);
+  if (selectorTokens === void 0) {
+    selectorTokens = parseRelevantSelectors(sel);
+    selectorTokensCache.set(sel, selectorTokens);
+  }
+  if (selectorTokens) {
+    for (const token of selectorTokens) {
+      if (token.name === "class") {
         return classCache.has(token.value);
       }
-      if (token.type === "attribute" && token.name === "id") {
+      if (token.name === "id") {
         return idCache.has(token.value);
       }
     }
   }
   return !!selectOne(sel, node);
 }
+function parseRelevantSelectors(sel) {
+  const tokens = parse$1(sel);
+  const relevantTokens = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tokenGroup = tokens[i];
+    if (tokenGroup?.length !== 1) {
+      continue;
+    }
+    const token = tokenGroup[0];
+    if (token?.type === "attribute" && (token.name === "class" || token.name === "id")) {
+      relevantTokens.push(token);
+    }
+  }
+  return relevantTokens.length > 0 ? relevantTokens : null;
+}
 
 const LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "silent"];
 const defaultLogger = {
@@ -11380,8 +11419,25 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var _selectorCache;
+const removePseudoClassesAndElementsPattern = /(?<!\\)::?[a-z-]+(?:\(.+\))?/gi;
+const removeTrailingCommasPattern = /\(\s*,|,\s*\)/g;
 class Beasties {
   constructor(options = {}) {
+    __privateAdd(this, _selectorCache, /* @__PURE__ */ new Map());
     __publicField(this, "options");
     __publicField(this, "logger");
     __publicField(this, "fs");
@@ -11422,22 +11478,20 @@ class Beasties {
     const start = Date.now();
     const document = createDocument(html);
     if (this.options.additionalStylesheets.length > 0) {
-      this.embedAdditionalStylesheet(document);
+      await this.embedAdditionalStylesheet(document);
     }
     if (this.options.external !== false) {
-      const externalSheets = [].slice.call(
-        document.querySelectorAll('link[rel="stylesheet"]')
-      );
+      const externalSheets = [...document.querySelectorAll('link[rel="stylesheet"]')];
       await Promise.all(
         externalSheets.map((link) => this.embedLinkedStylesheet(link, document))
       );
     }
     const styles = this.getAffectedStyleTags(document);
-    await Promise.all(
-      styles.map((style) => this.processStyle(style, document))
-    );
+    for (const style of styles) {
+      this.processStyle(style, document);
+    }
     if (this.options.mergeStylesheets !== false && styles.length !== 0) {
-      await this.mergeStylesheets(document);
+      this.mergeStylesheets(document);
     }
     const output = serializeDocument(document);
     const end = Date.now();
@@ -11454,7 +11508,7 @@ class Beasties {
     }
     return styles;
   }
-  async mergeStylesheets(document) {
+  mergeStylesheets(document) {
     const styles = this.getAffectedStyleTags(document);
     if (styles.length === 0) {
       this.logger.warn?.(
@@ -11641,7 +11695,7 @@ class Beasties {
   /**
    * Parse the stylesheet within a <style> element, then reduce it to contain only rules used by the document.
    */
-  async processStyle(style, document) {
+  processStyle(style, document) {
     if (style.$$reduce === false)
       return;
     const name = style.$$name ? style.$$name.replace(/^\//, "") : "inline CSS";
@@ -11720,10 +11774,10 @@ class Beasties {
             });
             if (isAllowedRule)
               return true;
-            if (sel === ":root" || sel === "html" || sel === "body" || /^::?(?:before|after)$/.test(sel)) {
+            if (sel === ":root" || sel === "html" || sel === "body" || sel[0] === ":" && /^::?(?:before|after)$/.test(sel)) {
               return true;
             }
-            sel = sel.replace(/(?<!\\)::?[a-z-]+(?![a-z-(])/gi, "").replace(/::?not\(\s*\)/g, "").replace(/\(\s*,/g, "(").replace(/,\s*\)/g, ")").trim();
+            sel = this.normalizeCssSelector(sel);
             if (!sel)
               return false;
             try {
@@ -11756,8 +11810,8 @@ class Beasties {
         }
         if (rule.type === "atrule" && rule.name === "font-face")
           return;
-        const rules = "nodes" in rule ? rule.nodes?.filter((rule2) => !rule2.$$remove) : void 0;
-        return !rules || rules.length !== 0;
+        const hasRemainingRules = ("nodes" in rule && rule.nodes?.some((rule2) => !rule2.$$remove)) ?? true;
+        return hasRemainingRules;
       })
     );
     if (failedSelectors.length !== 0) {
@@ -11839,7 +11893,17 @@ class Beasties {
       `\x1B[32mInlined ${formatSize(sheet.length)} (${percent}% of original ${formatSize(before.length)}) of ${name}${afterText}.\x1B[39m`
     );
   }
+  normalizeCssSelector(sel) {
+    let normalizedSelector = __privateGet(this, _selectorCache).get(sel);
+    if (normalizedSelector !== void 0) {
+      return normalizedSelector;
+    }
+    normalizedSelector = sel.replace(removePseudoClassesAndElementsPattern, "").replace(removeTrailingCommasPattern, (match) => match.includes("(") ? "(" : ")").trim();
+    __privateGet(this, _selectorCache).set(sel, normalizedSelector);
+    return normalizedSelector;
+  }
 }
+_selectorCache = new WeakMap();
 function formatSize(size) {
   if (size <= 0) {
     return "0 bytes";