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

package/esm2022/public_api.mjs

@@ -1,9 +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
- */
-export { CommonEngine, } from './src/common-engine/common-engine';
-export { getRoutesFromAngularRouterConfig as ɵgetRoutesFromAngularRouterConfig } from './src/routes/ng-routes';

package/esm2022/src/app-engine.mjs

@@ -1,106 +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 { Hooks } from './hooks';
-import { getPotentialLocaleIdFromUrl } from './i18n';
-import { getAngularAppEngineManifest } from './manifest';
-/**
- * Angular server application engine.
- * Manages Angular server applications (including localized ones), handles rendering requests,
- * and optionally transforms index HTML before rendering.
- */
-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.
-     */
-    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.
-     * @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.
-     *
-     * 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.
-     *
-     * 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
-     * corresponding to `https://www.example.com/page`.
-     *
-     * @param request - The incoming HTTP request object to be rendered.
-     * @param requestContext - Optional additional context for the request, such as metadata.
-     * @returns A promise that resolves to a Response object, or `null` if the request URL represents a file (e.g., `./logo.png`)
-     * rather than an application route.
-     */
-    async render(request, requestContext) {
-        // Skip if the request looks like a file but not `/index.html`.
-        const url = new URL(request.url);
-        const entryPoint = this.getEntryPointFromUrl(url);
-        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);
-            }
-        }
-        return serverApp.render(request, requestContext);
-    }
-    /**
-     * 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 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.
-     */
-    getEntryPointFromUrl(url) {
-        // Find bundle for locale
-        const { entryPoints, basePath } = this.manifest;
-        if (entryPoints.size === 1) {
-            return entryPoints.entries().next().value;
-        }
-        const potentialLocale = getPotentialLocaleIdFromUrl(url, basePath);
-        const entryPoint = entryPoints.get(potentialLocale);
-        return entryPoint ? [potentialLocale, entryPoint] : null;
-    }
-}

package/esm2022/src/app.mjs

@@ -1,85 +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 { ServerAssets } from './assets';
-import { Hooks } from './hooks';
-import { getAngularAppManifest } from './manifest';
-import { ServerRenderContext, render } from './render';
-import { ServerRouter } from './routes/router';
-/**
- * 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;
-    /**
-     * 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
-     */
-    isDevMode;
-    /**
-     * 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.
-     *
-     * This method processes the request and returns a response based on the specified rendering context.
-     *
-     * @param request - The incoming HTTP request to be rendered.
-     * @param requestContext - Optional additional context for rendering, such as request metadata.
-     * @param serverContext - The rendering context.
-     *
-     * @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) {
-        const url = new URL(request.url);
-        this.router ??= await ServerRouter.from(this.manifest, url);
-        const matchedRoute = this.router.match(url);
-        if (!matchedRoute) {
-            // Not a known Angular route.
-            return null;
-        }
-        const { redirectTo } = matchedRoute;
-        if (redirectTo !== undefined) {
-            // 302 Found is used by default for redirections
-            // 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);
-    }
-}

package/esm2022/src/assets.mjs

@@ -1,44 +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
- */
-/**
- * Manages server-side assets.
- */
-export class ServerAssets {
-    manifest;
-    /**
-     * Creates an instance of ServerAsset.
-     *
-     * @param manifest - The manifest containing the server assets.
-     */
-    constructor(manifest) {
-        this.manifest = manifest;
-    }
-    /**
-     * Retrieves the content of a server-side asset using its path.
-     *
-     * @param path - The path to the server asset.
-     * @returns A promise that resolves to the asset content as a string.
-     * @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];
-        if (!asset) {
-            throw new Error(`Server asset '${path}' does not exist.`);
-        }
-        return asset();
-    }
-    /**
-     * Retrieves and caches the content of 'index.server.html'.
-     *
-     * @returns A promise that resolves to the content of 'index.server.html'.
-     * @throws Error If there is an issue retrieving the asset.
-     */
-    getIndexServerHtml() {
-        return this.getServerAsset('index.server.html');
-    }
-}

package/esm2022/src/common-engine/inline-css-processor.mjs

@@ -1,181 +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 Critters from 'critters';
-import { readFile } from 'node:fs/promises';
-/**
- * Pattern used to extract the media query set by Critters in an `onload` handler.
- */
-const MEDIA_SET_HANDLER_PATTERN = /^this\.media=["'](.*)["'];?$/;
-/**
- * Name of the attribute used to save the Critters media query so it can be re-assigned on load.
- */
-const CSP_MEDIA_ATTR = 'ngCspMedia';
-/**
- * Script text used to change the media value of the link tags.
- *
- * NOTE:
- * We do not use `document.querySelectorAll('link').forEach((s) => s.addEventListener('load', ...)`
- * because this does not always fire on Chome.
- * See: https://github.com/angular/angular-cli/issues/26932 and https://crbug.com/1521256
- */
-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 {
-    optionsExtended;
-    resourceCache;
-    warnings = [];
-    errors = [];
-    initialEmbedLinkedStylesheet;
-    addedCspScriptsDocuments = new WeakSet();
-    documentNonces = new WeakMap();
-    constructor(optionsExtended, resourceCache) {
-        super({
-            logger: {
-                warn: (s) => this.warnings.push(s),
-                error: (s) => this.errors.push(s),
-                info: () => { },
-            },
-            logLevel: 'warn',
-            path: optionsExtended.outputPath,
-            publicPath: optionsExtended.deployUrl,
-            compress: !!optionsExtended.minify,
-            pruneSource: false,
-            reduceInlineStyles: false,
-            mergeStylesheets: false,
-            // Note: if `preload` changes to anything other than `media`, the logic in
-            // `embedLinkedStylesheetOverride` will have to be updated.
-            preload: 'media',
-            noscriptFallback: true,
-            inlineFonts: true,
-        });
-        this.optionsExtended = optionsExtended;
-        this.resourceCache = resourceCache;
-        // 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;
-    }
-    async readFile(path) {
-        let resourceContent = this.resourceCache.get(path);
-        if (resourceContent === undefined) {
-            resourceContent = await readFile(path, 'utf-8');
-            this.resourceCache.set(path, resourceContent);
-        }
-        return resourceContent;
-    }
-    /**
-     * Override of the Critters `embedLinkedStylesheet` method
-     * that makes it work with Angular's CSP APIs.
-     */
-    embedLinkedStylesheetOverride = async (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.
-            const media = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);
-            if (media) {
-                link.removeAttribute('onload');
-                link.setAttribute('media', media[1]);
-                link?.next?.remove();
-            }
-        }
-        const returnValue = await this.initialEmbedLinkedStylesheet(link, document);
-        const cspNonce = this.findCspNonce(document);
-        if (cspNonce) {
-            const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);
-            if (crittersMedia) {
-                // If there's a Critters-generated `onload` handler and the file has an Angular CSP nonce,
-                // we have to remove the handler, because it's incompatible with CSP. We save the value
-                // in a different attribute and we generate a script tag with the nonce that uses
-                // `addEventListener` to apply the media query instead.
-                link.removeAttribute('onload');
-                link.setAttribute(CSP_MEDIA_ATTR, crittersMedia[1]);
-                this.conditionallyInsertCspLoadingScript(document, cspNonce, link);
-            }
-            // Ideally we would hook in at the time Critters inserts the `style` tags, but there isn't
-            // a way of doing that at the moment so we fall back to doing it any time a `link` tag is
-            // inserted. We mitigate it by only iterating the direct children of the `<head>` which
-            // should be pretty shallow.
-            document.head.children.forEach((child) => {
-                if (child.tagName === 'style' && !child.hasAttribute('nonce')) {
-                    child.setAttribute('nonce', cspNonce);
-                }
-            });
-        }
-        return returnValue;
-    };
-    /**
-     * Finds the CSP nonce for a specific document.
-     */
-    findCspNonce(document) {
-        if (this.documentNonces.has(document)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return this.documentNonces.get(document);
-        }
-        // HTML attribute are case-insensitive, but the parser used by Critters is case-sensitive.
-        const nonceElement = document.querySelector('[ngCspNonce], [ngcspnonce]');
-        const cspNonce = nonceElement?.getAttribute('ngCspNonce') || nonceElement?.getAttribute('ngcspnonce') || null;
-        this.documentNonces.set(document, cspNonce);
-        return cspNonce;
-    }
-    /**
-     * Inserts the `script` tag that swaps the critical CSS at runtime,
-     * if one hasn't been inserted into the document already.
-     */
-    conditionallyInsertCspLoadingScript(document, nonce, link) {
-        if (this.addedCspScriptsDocuments.has(document)) {
-            return;
-        }
-        if (document.head.textContent.includes(LINK_LOAD_SCRIPT_CONTENT)) {
-            // Script was already added during the build.
-            this.addedCspScriptsDocuments.add(document);
-            return;
-        }
-        const script = document.createElement('script');
-        script.setAttribute('nonce', nonce);
-        script.textContent = LINK_LOAD_SCRIPT_CONTENT;
-        // Prepend the script to the head since it needs to
-        // run as early as possible, before the `link` tags.
-        document.head.insertBefore(script, link);
-        this.addedCspScriptsDocuments.add(document);
-    }
-}
-export class InlineCriticalCssProcessor {
-    options;
-    resourceCache = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    async process(html, options) {
-        const critters = new CrittersExtended({ ...this.options, ...options }, this.resourceCache);
-        const content = await critters.process(html);
-        return {
-            content,
-            errors: critters.errors.length ? critters.errors : undefined,
-            warnings: critters.warnings.length ? critters.warnings : undefined,
-        };
-    }
-}

package/esm2022/src/common-engine/peformance-profiler.mjs

@@ -1,50 +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
- */
-const PERFORMANCE_MARK_PREFIX = '🅰️';
-export function printPerformanceLogs() {
-    let maxWordLength = 0;
-    const benchmarks = [];
-    for (const { name, duration } of performance.getEntriesByType('measure')) {
-        if (!name.startsWith(PERFORMANCE_MARK_PREFIX)) {
-            continue;
-        }
-        // `🅰️:Retrieve SSG Page` -> `Retrieve SSG Page:`
-        const step = name.slice(PERFORMANCE_MARK_PREFIX.length + 1) + ':';
-        if (step.length > maxWordLength) {
-            maxWordLength = step.length;
-        }
-        benchmarks.push([step, `${duration.toFixed(1)}ms`]);
-        performance.clearMeasures(name);
-    }
-    /* eslint-disable no-console */
-    console.log('********** Performance results **********');
-    for (const [step, value] of benchmarks) {
-        const spaces = maxWordLength - step.length + 5;
-        console.log(step + ' '.repeat(spaces) + value);
-    }
-    console.log('*****************************************');
-    /* eslint-enable no-console */
-}
-export async function runMethodAndMeasurePerf(label, asyncMethod) {
-    const labelName = `${PERFORMANCE_MARK_PREFIX}:${label}`;
-    const startLabel = `start:${labelName}`;
-    const endLabel = `end:${labelName}`;
-    try {
-        performance.mark(startLabel);
-        return await asyncMethod();
-    }
-    finally {
-        performance.mark(endLabel);
-        performance.measure(labelName, startLabel, endLabel);
-        performance.clearMarks(startLabel);
-        performance.clearMarks(endLabel);
-    }
-}
-export function noopRunMethodAndMeasurePerf(label, asyncMethod) {
-    return asyncMethod();
-}

package/esm2022/src/console.mjs

@@ -1,34 +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 { ɵConsole } from '@angular/core';
-/**
- * Custom implementation of the Angular Console service that filters out specific log messages.
- *
- * This class extends the internal Angular `ɵConsole` class to provide customized logging behavior.
- * It overrides the `log` method to suppress logs that match certain predefined messages.
- */
-export class Console extends ɵConsole {
-    /**
-     * A set of log messages that should be ignored and not printed to the console.
-     */
-    ignoredLogs = new Set(['Angular is running in development mode.']);
-    /**
-     * Logs a message to the console if it is not in the set of ignored messages.
-     *
-     * @param message - The message to log to the console.
-     *
-     * This method overrides the `log` method of the `ɵConsole` class. It checks if the
-     * message is in the `ignoredLogs` set. If it is not, it delegates the logging to
-     * the parent class's `log` method. Otherwise, the message is suppressed.
-     */
-    log(message) {
-        if (!this.ignoredLogs.has(message)) {
-            super.log(message);
-        }
-    }
-}

package/esm2022/src/hooks.mjs

@@ -1,94 +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
- */
-/**
- * Manages a collection of hooks and provides methods to register and execute them.
- * Hooks are functions that can be invoked with specific arguments to allow modifications or enhancements.
- */
-export class Hooks {
-    /**
-     * A map of hook names to arrays of hook functions.
-     * Each hook name can have multiple associated functions, which are executed in sequence.
-     */
-    store = new Map();
-    /**
-     * Executes all hooks associated with the specified name, passing the given argument to each hook function.
-     * The hooks are invoked sequentially, and the argument may be modified by each hook.
-     *
-     * @template Hook - The type of the hook name. It should be one of the keys of `HooksMapping`.
-     * @param name - The name of the hook whose functions will be executed.
-     * @param context - The input value to be passed to each hook function. The value is mutated by each hook function.
-     * @returns A promise that resolves once all hook functions have been executed.
-     *
-     * @example
-     * ```typescript
-     * const hooks = new Hooks();
-     * hooks.on('html:transform:pre', async (ctx) => {
-     *   ctx.html = ctx.html.replace(/foo/g, 'bar');
-     *   return ctx.html;
-     * });
-     * const result = await hooks.run('html:transform:pre', { html: '<div>foo</div>' });
-     * console.log(result); // '<div>bar</div>'
-     * ```
-     * @internal
-     */
-    async run(name, context) {
-        const hooks = this.store.get(name);
-        switch (name) {
-            case 'html:transform:pre': {
-                if (!hooks) {
-                    return context.html;
-                }
-                const ctx = { ...context };
-                for (const hook of hooks) {
-                    ctx.html = await hook(ctx);
-                }
-                return ctx.html;
-            }
-            default:
-                throw new Error(`Running hook "${name}" is not supported.`);
-        }
-    }
-    /**
-     * Registers a new hook function under the specified hook name.
-     * This function should be a function that takes an argument of type `T` and returns a `string` or `Promise<string>`.
-     *
-     * @template Hook - The type of the hook name. It should be one of the keys of `HooksMapping`.
-     * @param name - The name of the hook under which the function will be registered.
-     * @param handler - A function to be executed when the hook is triggered. The handler will be called with an argument
-     *                  that may be modified by the hook functions.
-     *
-     * @remarks
-     * - If there are existing handlers registered under the given hook name, the new handler will be added to the list.
-     * - If no handlers are registered under the given hook name, a new list will be created with the handler as its first element.
-     *
-     * @example
-     * ```typescript
-     * hooks.on('html:transform:pre', async (ctx) => {
-     *   return ctx.html.replace(/foo/g, 'bar');
-     * });
-     * ```
-     */
-    on(name, handler) {
-        const hooks = this.store.get(name);
-        if (hooks) {
-            hooks.push(handler);
-        }
-        else {
-            this.store.set(name, [handler]);
-        }
-    }
-    /**
-     * Checks if there are any hooks registered under the specified name.
-     *
-     * @param name - The name of the hook to check.
-     * @returns `true` if there are hooks registered under the specified name, otherwise `false`.
-     */
-    has(name) {
-        return !!this.store.get(name)?.length;
-    }
-}

package/esm2022/src/i18n.mjs

@@ -1,41 +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
- */
-/**
- * Extracts a potential locale ID from a given URL based on the specified base path.
- *
- * This function parses the URL to locate a potential locale identifier that immediately
- * follows the base path segment in the URL's pathname. If the URL does not contain a valid
- * locale ID, an empty string is returned.
- *
- * @param url - The full URL from which to extract the locale ID.
- * @param basePath - The base path used as the reference point for extracting the locale ID.
- * @returns The extracted locale ID if present, or an empty string if no valid locale ID is found.
- *
- * @example
- * ```js
- * const url = new URL('https://example.com/base/en/page');
- * const basePath = '/base';
- * const localeId = getPotentialLocaleIdFromUrl(url, basePath);
- * console.log(localeId); // Output: 'en'
- * ```
- */
-export function getPotentialLocaleIdFromUrl(url, basePath) {
-    const { pathname } = url;
-    // Move forward of the base path section.
-    let start = basePath.length;
-    if (pathname[start] === '/') {
-        start++;
-    }
-    // Find the next forward slash.
-    let end = pathname.indexOf('/', start);
-    if (end === -1) {
-        end = pathname.length;
-    }
-    // Extract the potential locale id.
-    return pathname.slice(start, end);
-}