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

package/src/tools/esbuild/angular/compiler-plugin.js

@@ -35,6 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompilerPlugin = createCompilerPlugin;
 const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
 const path = __importStar(require("node:path"));
 const environment_options_1 = require("../../../utils/environment-options");
 const compilation_1 = require("../../angular/compilation");
@@ -120,13 +121,14 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                 // Angular compiler which does not have direct knowledge of transitive resource
                 // dependencies or web worker processing.
                 let modifiedFiles;
+                let invalidatedStylesheetEntries;
                 if (pluginOptions.sourceFileCache?.modifiedFiles.size &&
                     referencedFileTracker &&
                     !pluginOptions.noopTypeScriptCompilation) {
                     // TODO: Differentiate between changed input files and stale output files
                     modifiedFiles = referencedFileTracker.update(pluginOptions.sourceFileCache.modifiedFiles);
                     pluginOptions.sourceFileCache.invalidate(modifiedFiles);
-                    stylesheetBundler.invalidate(modifiedFiles);
+                    invalidatedStylesheetEntries = stylesheetBundler.invalidate(modifiedFiles);
                 }
                 if (!pluginOptions.noopTypeScriptCompilation &&
                     compilation.update &&
@@ -138,7 +140,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     fileReplacements: pluginOptions.fileReplacements,
                     modifiedFiles,
                     sourceFileCache: pluginOptions.sourceFileCache,
-                    async transformStylesheet(data, containingFile, stylesheetFile) {
+                    async transformStylesheet(data, containingFile, stylesheetFile, order) {
                         let stylesheetResult;
                         // Stylesheet file only exists for external stylesheets
                         if (stylesheetFile) {
@@ -147,7 +149,17 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                         else {
                             stylesheetResult = await stylesheetBundler.bundleInline(data, containingFile, 
                             // Inline stylesheets from a template style element are always CSS
-                            containingFile.endsWith('.html') ? 'css' : styleOptions.inlineStyleLanguage);
+                            containingFile.endsWith('.html') ? 'css' : styleOptions.inlineStyleLanguage, 
+                            // When external runtime styles are enabled, an identifier for the style that does not change
+                            // based on the content is required to avoid emitted JS code changes. Any JS code changes will
+                            // invalid the output and force a full page reload for HMR cases. The containing file and order
+                            // of the style within the containing file is used.
+                            pluginOptions.externalRuntimeStyles
+                                ? (0, node_crypto_1.createHash)('sha-256')
+                                    .update(containingFile)
+                                    .update((order ?? 0).toString())
+                                    .digest('hex')
+                                : undefined);
                         }
                         const { contents, outputFiles, metafile, referencedFiles, errors, warnings } = stylesheetResult;
                         if (errors) {
@@ -201,6 +213,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                 // Initialize the Angular compilation for the current build.
                 // In watch mode, previous build state will be reused.
                 let referencedFiles;
+                let externalStylesheets;
                 try {
                     const initializationResult = await compilation.initialize(pluginOptions.tsconfig, hostOptions, createCompilerOptionsTransformer(setupWarnings, pluginOptions, preserveSymlinks));
                     shouldTsIgnoreJs = !initializationResult.compilerOptions.allowJs;
@@ -211,6 +224,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                             !!initializationResult.compilerOptions.sourceMap ||
                             !!initializationResult.compilerOptions.inlineSourceMap;
                     referencedFiles = initializationResult.referencedFiles;
+                    externalStylesheets = initializationResult.externalStylesheets;
                 }
                 catch (error) {
                     (result.errors ??= []).push({
@@ -231,6 +245,19 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     hasCompilationErrors = await sharedTSCompilationState.waitUntilReady;
                     return result;
                 }
+                if (externalStylesheets) {
+                    // Process any new external stylesheets
+                    for (const [stylesheetFile, externalId] of externalStylesheets) {
+                        await bundleExternalStylesheet(stylesheetBundler, stylesheetFile, externalId, result, additionalResults);
+                    }
+                    // Process any updated stylesheets
+                    if (invalidatedStylesheetEntries) {
+                        for (const stylesheetFile of invalidatedStylesheetEntries) {
+                            // externalId is already linked in the bundler context so only enabling is required here
+                            await bundleExternalStylesheet(stylesheetBundler, stylesheetFile, true, result, additionalResults);
+                        }
+                    }
+                }
                 // Update TypeScript file output cache for all affected files
                 try {
                     await (0, profiling_1.profileAsync)('NG_EMIT_TS', async () => {
@@ -312,7 +339,8 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     // A string indicates untransformed output from the TS/NG compiler.
                     // This step is unneeded when using esbuild transpilation.
                     const sideEffects = await hasSideEffects(request);
-                    contents = await javascriptTransformer.transformData(request, contents, true /* skipLinker */, sideEffects);
+                    const instrumentForCoverage = pluginOptions.instrumentForCoverage?.(request);
+                    contents = await javascriptTransformer.transformData(request, contents, true /* skipLinker */, sideEffects, instrumentForCoverage);
                     // Store as the returned Uint8Array to allow caching the fully transformed code
                     typeScriptFileCache.set(request, contents);
                 }
@@ -376,6 +404,17 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
         },
     };
 }
+async function bundleExternalStylesheet(stylesheetBundler, stylesheetFile, externalId, result, additionalResults) {
+    const { outputFiles, metafile, errors, warnings } = await stylesheetBundler.bundleFile(stylesheetFile, externalId);
+    if (errors) {
+        (result.errors ??= []).push(...errors);
+    }
+    (result.warnings ??= []).push(...warnings);
+    additionalResults.set(stylesheetFile, {
+        outputFiles,
+        metafile,
+    });
+}
 function createCompilerOptionsTransformer(setupWarnings, pluginOptions, preserveSymlinks) {
     return (compilerOptions) => {
         // target of 9 is ES2022 (using the number avoids an expensive import of typescript just for an enum)
@@ -433,6 +472,7 @@ function createCompilerOptionsTransformer(setupWarnings, pluginOptions, preserve
             mapRoot: undefined,
             sourceRoot: undefined,
             preserveSymlinks,
+            externalRuntimeStyles: pluginOptions.externalRuntimeStyles,
         };
     };
 }

package/src/tools/esbuild/angular/component-stylesheets.d.ts

@@ -22,7 +22,7 @@ export declare class ComponentStylesheetBundler {
      * @param cache A load result cache to use when bundling.
      */
     constructor(options: BundleStylesheetOptions, incremental: boolean);
-    bundleFile(entry: string): Promise<{
+    bundleFile(entry: string, externalId?: string | boolean): Promise<{
         errors: import("esbuild").Message[] | undefined;
         warnings: import("esbuild").Message[];
         contents: string;
@@ -30,7 +30,7 @@ export declare class ComponentStylesheetBundler {
         metafile: import("esbuild").Metafile | undefined;
         referencedFiles: Set<string> | undefined;
     }>;
-    bundleInline(data: string, filename: string, language: string): Promise<{
+    bundleInline(data: string, filename: string, language: string, externalId?: string): Promise<{
         errors: import("esbuild").Message[] | undefined;
         warnings: import("esbuild").Message[];
         contents: string;
@@ -38,7 +38,12 @@ export declare class ComponentStylesheetBundler {
         metafile: import("esbuild").Metafile | undefined;
         referencedFiles: Set<string> | undefined;
     }>;
-    invalidate(files: Iterable<string>): void;
+    /**
+     * Invalidates both file and inline based component style bundling state for a set of modified files.
+     * @param files The group of files that have been modified
+     * @returns An array of file based stylesheet entries if any were invalidated; otherwise, undefined.
+     */
+    invalidate(files: Iterable<string>): string[] | undefined;
     dispose(): Promise<void>;
     private extractResult;
 }

package/src/tools/esbuild/angular/component-stylesheets.js

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentStylesheetBundler = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = __importDefault(require("node:path"));
 const bundler_context_1 = require("../bundler-context");
@@ -35,21 +36,31 @@ class ComponentStylesheetBundler {
         this.options = options;
         this.incremental = incremental;
     }
-    async bundleFile(entry) {
+    async bundleFile(entry, externalId) {
         const bundlerContext = await this.#fileContexts.getOrCreate(entry, () => {
             return new bundler_context_1.BundlerContext(this.options.workspaceRoot, this.incremental, (loadCache) => {
                 const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)(this.options, loadCache);
-                buildOptions.entryPoints = [entry];
+                if (externalId) {
+                    (0, node_assert_1.default)(typeof externalId === 'string', 'Initial external component stylesheets must have a string identifier');
+                    buildOptions.entryPoints = { [externalId]: entry };
+                    delete buildOptions.publicPath;
+                }
+                else {
+                    buildOptions.entryPoints = [entry];
+                }
                 return buildOptions;
             });
         });
-        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
+        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles, !!externalId);
     }
-    async bundleInline(data, filename, language) {
+    async bundleInline(data, filename, language, externalId) {
         // Use a hash of the inline stylesheet content to ensure a consistent identifier. External stylesheets will resolve
         // to the actual stylesheet file path.
         // TODO: Consider xxhash instead for hashing
-        const id = (0, node_crypto_1.createHash)('sha256').update(data).digest('hex');
+        const id = (0, node_crypto_1.createHash)('sha256')
+            .update(data)
+            .update(externalId ?? '')
+            .digest('hex');
         const entry = [language, id, filename].join(';');
         const bundlerContext = await this.#inlineContexts.getOrCreate(entry, () => {
             const namespace = 'angular:styles/component';
@@ -57,7 +68,13 @@ class ComponentStylesheetBundler {
                 const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)(this.options, loadCache, {
                     [entry]: data,
                 });
-                buildOptions.entryPoints = [`${namespace};${entry}`];
+                if (externalId) {
+                    buildOptions.entryPoints = { [externalId]: `${namespace};${entry}` };
+                    delete buildOptions.publicPath;
+                }
+                else {
+                    buildOptions.entryPoints = [`${namespace};${entry}`];
+                }
                 buildOptions.plugins.push({
                     name: 'angular-component-styles',
                     setup(build) {
@@ -83,19 +100,29 @@ class ComponentStylesheetBundler {
             });
         });
         // Extract the result of the bundling from the output files
-        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
+        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles, !!externalId);
     }
+    /**
+     * Invalidates both file and inline based component style bundling state for a set of modified files.
+     * @param files The group of files that have been modified
+     * @returns An array of file based stylesheet entries if any were invalidated; otherwise, undefined.
+     */
     invalidate(files) {
         if (!this.incremental) {
             return;
         }
         const normalizedFiles = [...files].map(node_path_1.default.normalize);
-        for (const bundler of this.#fileContexts.values()) {
-            bundler.invalidate(normalizedFiles);
+        let entries;
+        for (const [entry, bundler] of this.#fileContexts.entries()) {
+            if (bundler.invalidate(normalizedFiles)) {
+                entries ??= [];
+                entries.push(entry);
+            }
         }
         for (const bundler of this.#inlineContexts.values()) {
             bundler.invalidate(normalizedFiles);
         }
+        return entries;
     }
     async dispose() {
         const contexts = [...this.#fileContexts.values(), ...this.#inlineContexts.values()];
@@ -103,7 +130,7 @@ class ComponentStylesheetBundler {
         this.#inlineContexts.clear();
         await Promise.allSettled(contexts.map((context) => context.dispose()));
     }
-    extractResult(result, referencedFiles) {
+    extractResult(result, referencedFiles, external) {
         let contents = '';
         let metafile;
         const outputFiles = [];
@@ -122,7 +149,15 @@ class ComponentStylesheetBundler {
                     outputFiles.push(clonedOutputFile);
                 }
                 else if (filename.endsWith('.css')) {
-                    contents = outputFile.text;
+                    if (external) {
+                        const clonedOutputFile = outputFile.clone();
+                        clonedOutputFile.path = node_path_1.default.join(this.options.workspaceRoot, outputFile.path);
+                        outputFiles.push(clonedOutputFile);
+                        contents = node_path_1.default.posix.join(this.options.publicPath ?? '', filename);
+                    }
+                    else {
+                        contents = outputFile.text;
+                    }
                 }
                 else {
                     throw new Error(`Unexpected non CSS/Media file "${filename}" outputted during component stylesheet processing.`);

package/src/tools/esbuild/angular/file-reference-tracker.d.ts

@@ -7,7 +7,7 @@
  */
 export declare class FileReferenceTracker {
     #private;
-    get referencedFiles(): IterableIterator<string>;
+    get referencedFiles(): MapIterator<string>;
     add(containingFile: string, referencedFiles: Iterable<string>): void;
     /**
      *

package/src/tools/esbuild/application-code-bundle.d.ts

@@ -11,10 +11,6 @@ import { SourceFileCache } from './angular/source-file-cache';
 import { BundlerOptionsFactory } from './bundler-context';
 export declare function createBrowserCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BuildOptions;
 export declare function createBrowserPolyfillBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BuildOptions | BundlerOptionsFactory | undefined;
-/**
- * Create an esbuild 'build' options object for the server bundle.
- * @param options The builder's user-provider normalized options.
- * @returns An esbuild BuildOptions object.
- */
-export declare function createServerCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache: SourceFileCache): BuildOptions;
 export declare function createServerPolyfillBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BundlerOptionsFactory | undefined;
+export declare function createServerMainCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache: SourceFileCache): BuildOptions;
+export declare function createSsrEntryCodeBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache: SourceFileCache): BuildOptions;

package/src/tools/esbuild/application-code-bundle.js

@@ -12,12 +12,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBrowserCodeBundleOptions = createBrowserCodeBundleOptions;
 exports.createBrowserPolyfillBundleOptions = createBrowserPolyfillBundleOptions;
-exports.createServerCodeBundleOptions = createServerCodeBundleOptions;
 exports.createServerPolyfillBundleOptions = createServerPolyfillBundleOptions;
+exports.createServerMainCodeBundleOptions = createServerMainCodeBundleOptions;
+exports.createSsrEntryCodeBundleOptions = createSsrEntryCodeBundleOptions;
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = require("node:path");
 const environment_options_1 = require("../../utils/environment-options");
+const manifest_1 = require("../../utils/server-rendering/manifest");
 const compiler_plugin_1 = require("./angular/compiler-plugin");
 const compiler_plugin_options_1 = require("./compiler-plugin-options");
 const external_packages_plugin_1 = require("./external-packages-plugin");
@@ -110,29 +112,28 @@ function createBrowserPolyfillBundleOptions(options, target, sourceFileCache) {
     // cannot be used with fully incremental bundling yet.
     return hasTypeScriptEntries ? buildOptions : () => buildOptions;
 }
-/**
- * Create an esbuild 'build' options object for the server bundle.
- * @param options The builder's user-provider normalized options.
- * @returns An esbuild BuildOptions object.
- */
-function createServerCodeBundleOptions(options, target, sourceFileCache) {
-    const { serverEntryPoint, workspaceRoot, ssrOptions, watch, externalPackages, prerenderOptions, polyfills, } = options;
-    (0, node_assert_1.default)(serverEntryPoint, 'createServerCodeBundleOptions should not be called without a defined serverEntryPoint.');
-    const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
-    const mainServerNamespace = 'angular:server-render-utils';
-    const entryPoints = {
-        'render-utils.server': mainServerNamespace,
-        'main.server': serverEntryPoint,
-    };
-    const ssrEntryPoint = ssrOptions?.entry;
-    if (ssrEntryPoint) {
-        entryPoints['server'] = ssrEntryPoint;
+function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
+    const serverPolyfills = [];
+    const polyfillsFromConfig = new Set(options.polyfills);
+    if (!(0, utils_1.isZonelessApp)(options.polyfills)) {
+        serverPolyfills.push('zone.js/node');
+    }
+    if (polyfillsFromConfig.has('@angular/localize') ||
+        polyfillsFromConfig.has('@angular/localize/init')) {
+        serverPolyfills.push('@angular/localize/init');
+    }
+    serverPolyfills.push('@angular/platform-server/init');
+    const namespace = 'angular:polyfills-server';
+    const polyfillBundleOptions = getEsBuildCommonPolyfillsOptions({
+        ...options,
+        polyfills: serverPolyfills,
+    }, namespace, false, sourceFileCache);
+    if (!polyfillBundleOptions) {
+        return;
     }
-    const zoneless = (0, utils_1.isZonelessApp)(polyfills);
     const buildOptions = {
-        ...getEsBuildCommonOptions(options),
+        ...polyfillBundleOptions,
         platform: 'node',
-        splitting: true,
         outExtension: { '.js': '.mjs' },
         // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
         // match and the ES5 distribution would be bundled and ends up breaking at
@@ -140,14 +141,46 @@ function createServerCodeBundleOptions(options, target, sourceFileCache) {
         // More details: https://github.com/angular/angular-cli/issues/25405.
         mainFields: ['es2020', 'es2015', 'module', 'main'],
         entryNames: '[name]',
-        target,
         banner: {
-            js: `import './polyfills.server.mjs';`,
+            js: [
+                // Note: Needed as esbuild does not provide require shims / proxy from ESModules.
+                // See: https://github.com/evanw/esbuild/issues/1921.
+                `import { createRequire } from 'node:module';`,
+                `globalThis['require'] ??= createRequire(import.meta.url);`,
+            ].join('\n'),
+        },
+        target,
+        entryPoints: {
+            'polyfills.server': namespace,
         },
+    };
+    return () => buildOptions;
+}
+function createServerMainCodeBundleOptions(options, target, sourceFileCache) {
+    const { serverEntryPoint: mainServerEntryPoint, workspaceRoot, outputMode, externalPackages, ssrOptions, polyfills, } = options;
+    (0, node_assert_1.default)(mainServerEntryPoint, 'createServerCodeBundleOptions should not be called without a defined serverEntryPoint.');
+    const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
+    const mainServerNamespace = 'angular:main-server';
+    const mainServerInjectPolyfillsNamespace = 'angular:main-server-inject-polyfills';
+    const mainServerInjectManifestNamespace = 'angular:main-server-inject-manifest';
+    const zoneless = (0, utils_1.isZonelessApp)(polyfills);
+    const entryPoints = {
+        'main.server': mainServerNamespace,
+    };
+    const ssrEntryPoint = ssrOptions?.entry;
+    const isOldBehaviour = !outputMode;
+    if (ssrEntryPoint && isOldBehaviour) {
+        // Old behavior: 'server.ts' was bundled together with the SSR (Server-Side Rendering) code.
+        // This approach combined server-side logic and rendering into a single bundle.
+        entryPoints['server'] = ssrEntryPoint;
+    }
+    const buildOptions = {
+        ...getEsBuildServerCommonOptions(options),
+        target,
+        inject: [mainServerInjectPolyfillsNamespace, mainServerInjectManifestNamespace],
         entryPoints,
         supported: (0, utils_1.getFeatureSupport)(target, zoneless),
         plugins: [
-            (0, loader_import_attribute_plugin_1.createLoaderImportAttributePlugin)(),
             (0, wasm_plugin_1.createWasmPlugin)({ allowAsync: zoneless, cache: sourceFileCache?.loadResultCache }),
             (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),
             (0, compiler_plugin_1.createCompilerPlugin)(
@@ -164,20 +197,48 @@ function createServerCodeBundleOptions(options, target, sourceFileCache) {
     else {
         buildOptions.plugins.push((0, rxjs_esm_resolution_plugin_1.createRxjsEsmResolutionPlugin)());
     }
+    // Mark manifest and polyfills file as external as these are generated by a different bundle step.
+    (buildOptions.external ??= []).push(...utils_1.SERVER_GENERATED_EXTERNALS);
     buildOptions.plugins.push((0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: mainServerInjectPolyfillsNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: () => ({
+            contents: `import './polyfills.server.mjs';`,
+            loader: 'js',
+            resolveDir: workspaceRoot,
+        }),
+    }), (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: mainServerInjectManifestNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: async () => {
+            const contents = [
+                // Configure `@angular/ssr` manifest.
+                `import manifest from './${manifest_1.SERVER_APP_MANIFEST_FILENAME}';`,
+                `import { ɵsetAngularAppManifest } from '@angular/ssr';`,
+                `ɵsetAngularAppManifest(manifest);`,
+            ];
+            return {
+                contents: contents.join('\n'),
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }), (0, virtual_module_plugin_1.createVirtualModulePlugin)({
         namespace: mainServerNamespace,
         cache: sourceFileCache?.loadResultCache,
         loadContent: async () => {
+            const mainServerEntryPointJsImport = entryFileToWorkspaceRelative(workspaceRoot, mainServerEntryPoint);
             const contents = [
-                `export { ɵConsole } from '@angular/core';`,
-                `export { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';`,
+                // Re-export all symbols including default export from 'main.server.ts'
+                `export { default } from '${mainServerEntryPointJsImport}';`,
+                `export * from '${mainServerEntryPointJsImport}';`,
+                // Add @angular/ssr exports
+                `export {
+            ɵdestroyAngularServerApp,
+            ɵextractRoutesAndCreateRouteTree,
+            ɵgetOrCreateAngularServerApp,
+          } from '@angular/ssr';`,
             ];
-            if (watch) {
-                contents.push(`export { ɵresetCompiledComponents } from '@angular/core';`);
-            }
-            if (prerenderOptions?.discoverRoutes) {
-                contents.push(`export { ɵgetRoutesFromAngularRouterConfig } from '@angular/ssr';`);
-            }
             return {
                 contents: contents.join('\n'),
                 loader: 'js',
@@ -190,27 +251,114 @@ function createServerCodeBundleOptions(options, target, sourceFileCache) {
     }
     return buildOptions;
 }
-function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
-    const serverPolyfills = [];
-    const polyfillsFromConfig = new Set(options.polyfills);
-    if (!(0, utils_1.isZonelessApp)(options.polyfills)) {
-        serverPolyfills.push('zone.js/node');
+function createSsrEntryCodeBundleOptions(options, target, sourceFileCache) {
+    const { workspaceRoot, ssrOptions, externalPackages } = options;
+    const serverEntryPoint = ssrOptions?.entry;
+    (0, node_assert_1.default)(serverEntryPoint, 'createSsrEntryCodeBundleOptions should not be called without a defined serverEntryPoint.');
+    const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
+    const ssrEntryNamespace = 'angular:ssr-entry';
+    const ssrInjectManifestNamespace = 'angular:ssr-entry-inject-manifest';
+    const ssrInjectRequireNamespace = 'angular:ssr-entry-inject-require';
+    const buildOptions = {
+        ...getEsBuildServerCommonOptions(options),
+        target,
+        entryPoints: {
+            // TODO: consider renaming to index
+            'server': ssrEntryNamespace,
+        },
+        supported: (0, utils_1.getFeatureSupport)(target, true),
+        plugins: [
+            (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),
+            (0, compiler_plugin_1.createCompilerPlugin)(
+            // JS/TS options
+            { ...pluginOptions, noopTypeScriptCompilation: true }, 
+            // Component stylesheet options
+            styleOptions),
+        ],
+        inject: [ssrInjectRequireNamespace, ssrInjectManifestNamespace],
+    };
+    buildOptions.plugins ??= [];
+    if (externalPackages) {
+        buildOptions.packages = 'external';
     }
-    if (polyfillsFromConfig.has('@angular/localize') ||
-        polyfillsFromConfig.has('@angular/localize/init')) {
-        serverPolyfills.push('@angular/localize/init');
+    else {
+        buildOptions.plugins.push((0, rxjs_esm_resolution_plugin_1.createRxjsEsmResolutionPlugin)());
     }
-    serverPolyfills.push('@angular/platform-server/init');
-    const namespace = 'angular:polyfills-server';
-    const polyfillBundleOptions = getEsBuildCommonPolyfillsOptions({
-        ...options,
-        polyfills: serverPolyfills,
-    }, namespace, false, sourceFileCache);
-    if (!polyfillBundleOptions) {
-        return;
+    // Mark manifest file as external. As this will be generated later on.
+    (buildOptions.external ??= []).push('*/main.server.mjs', ...utils_1.SERVER_GENERATED_EXTERNALS);
+    buildOptions.plugins.push({
+        name: 'angular-ssr-metadata',
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.metafile) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    result.metafile['ng-ssr-entry-bundle'] = true;
+                }
+            });
+        },
+    }, (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: ssrInjectRequireNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: () => {
+            const contents = [
+                // Note: Needed as esbuild does not provide require shims / proxy from ESModules.
+                // See: https://github.com/evanw/esbuild/issues/1921.
+                `import { createRequire } from 'node:module';`,
+                `globalThis['require'] ??= createRequire(import.meta.url);`,
+            ];
+            return {
+                contents: contents.join('\n'),
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }), (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: ssrInjectManifestNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: () => {
+            const contents = [
+                // Configure `@angular/ssr` app engine manifest.
+                `import manifest from './${manifest_1.SERVER_APP_ENGINE_MANIFEST_FILENAME}';`,
+                `import { ɵsetAngularAppEngineManifest } from '@angular/ssr';`,
+                `ɵsetAngularAppEngineManifest(manifest);`,
+            ];
+            return {
+                contents: contents.join('\n'),
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }), (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+        namespace: ssrEntryNamespace,
+        cache: sourceFileCache?.loadResultCache,
+        loadContent: () => {
+            const serverEntryPointJsImport = entryFileToWorkspaceRelative(workspaceRoot, serverEntryPoint);
+            const contents = [
+                // Re-export all symbols including default export
+                `import * as server from '${serverEntryPointJsImport}';`,
+                `export * from '${serverEntryPointJsImport}';`,
+                // The below is needed to avoid
+                // `Import "default" will always be undefined because there is no matching export` warning when no default is present.
+                `const defaultExportName = 'default';`,
+                `export default server[defaultExportName]`,
+                // Add @angular/ssr exports
+                `export { AngularAppEngine } from '@angular/ssr';`,
+            ];
+            return {
+                contents: contents.join('\n'),
+                loader: 'js',
+                resolveDir: workspaceRoot,
+            };
+        },
+    }));
+    if (options.plugins) {
+        buildOptions.plugins.push(...options.plugins);
     }
-    const buildOptions = {
-        ...polyfillBundleOptions,
+    return buildOptions;
+}
+function getEsBuildServerCommonOptions(options) {
+    return {
+        ...getEsBuildCommonOptions(options),
         platform: 'node',
         outExtension: { '.js': '.mjs' },
         // Note: `es2015` is needed for RxJS v6. If not specified, `module` would
@@ -219,31 +367,18 @@ function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
         // More details: https://github.com/angular/angular-cli/issues/25405.
         mainFields: ['es2020', 'es2015', 'module', 'main'],
         entryNames: '[name]',
-        banner: {
-            js: [
-                // Note: Needed as esbuild does not provide require shims / proxy from ESModules.
-                // See: https://github.com/evanw/esbuild/issues/1921.
-                `import { createRequire } from 'node:module';`,
-                `globalThis['require'] ??= createRequire(import.meta.url);`,
-            ].join('\n'),
-        },
-        target,
-        entryPoints: {
-            'polyfills.server': namespace,
-        },
     };
-    return () => buildOptions;
 }
 function getEsBuildCommonOptions(options) {
-    const { workspaceRoot, outExtension, optimizationOptions, sourcemapOptions, tsconfig, externalDependencies, outputNames, preserveSymlinks, jit, loaderExtensions, jsonLogs, } = options;
+    const { workspaceRoot, outExtension, optimizationOptions, sourcemapOptions, tsconfig, externalDependencies, outputNames, preserveSymlinks, jit, loaderExtensions, jsonLogs, i18nOptions, } = options;
     // Ensure unique hashes for i18n translation changes when using post-process inlining.
     // This hash value is added as a footer to each file and ensures that the output file names (with hashes)
     // change when translation files have changed. If this is not done the post processed files may have
     // different content but would retain identical production file names which would lead to browser caching problems.
     let footer;
-    if (options.i18nOptions.shouldInline) {
+    if (i18nOptions.shouldInline) {
         // Update file hashes to include translation file content
-        const i18nHash = Object.values(options.i18nOptions.locales).reduce((data, locale) => data + locale.files.map((file) => file.integrity || '').join('|'), '');
+        const i18nHash = Object.values(i18nOptions.locales).reduce((data, locale) => data + locale.files.map((file) => file.integrity || '').join('|'), '');
         footer = { js: `/**i18n:${(0, node_crypto_1.createHash)('sha256').update(i18nHash).digest('hex')}*/` };
     }
     return {
@@ -267,7 +402,7 @@ function getEsBuildCommonOptions(options) {
         splitting: true,
         chunkNames: options.namedChunks ? '[name]-[hash]' : 'chunk-[hash]',
         tsconfig,
-        external: externalDependencies,
+        external: externalDependencies ? [...externalDependencies] : undefined,
         write: false,
         preserveSymlinks,
         define: {
@@ -360,3 +495,9 @@ function getEsBuildCommonPolyfillsOptions(options, namespace, tryToResolvePolyfi
     }));
     return buildOptions;
 }
+function entryFileToWorkspaceRelative(workspaceRoot, entryFile) {
+    return ('./' +
+        (0, node_path_1.relative)(workspaceRoot, entryFile)
+            .replace(/.[mc]?ts$/, '')
+            .replace(/\\/g, '/'));
+}