feat(@angular-devkit/build-angular): add initial support for server bundle generation using esbuild

This commit adds initial support to generate the server bundle using esbuild as the underlying bundler.

Author: alan-agius4

packages/angular_devkit/build_angular/src/builders/application/execute-build.ts

@@ -8,14 +8,15 @@
 
 import { BuilderContext } from '@angular-devkit/architect';
 import { SourceFileCache } from '../../tools/esbuild/angular/compiler-plugin';
-import { createCodeBundleOptions } from '../../tools/esbuild/application-code-bundle';
+import { createBrowserCodeBundleOptions } from '../../tools/esbuild/browser-code-bundle';
 import { BundlerContext } from '../../tools/esbuild/bundler-context';
 import { ExecutionResult, RebuildState } from '../../tools/esbuild/bundler-execution-result';
 import { checkCommonJSModules } from '../../tools/esbuild/commonjs-checker';
 import { createGlobalScriptsBundleOptions } from '../../tools/esbuild/global-scripts';
 import { createGlobalStylesBundleOptions } from '../../tools/esbuild/global-styles';
 import { generateIndexHtml } from '../../tools/esbuild/index-html-generator';
 import { extractLicenses } from '../../tools/esbuild/license-extractor';
+import { createServerCodeBundleOptions } from '../../tools/esbuild/server-code-bundle';
 import {
   calculateEstimatedTransferSizes,
   logBuildStats,
@@ -39,6 +40,7 @@ export async function executeBuild(
     workspaceRoot,
     serviceWorker,
     optimizationOptions,
+    serverEntryPoint,
     assets,
     indexHtmlOptions,
     cacheOptions,
@@ -55,12 +57,12 @@ export async function executeBuild(
   if (bundlerContexts === undefined) {
     bundlerContexts = [];
 
-    // Application code
+    // Browser application code
     bundlerContexts.push(
       new BundlerContext(
         workspaceRoot,
         !!options.watch,
-        createCodeBundleOptions(options, target, browsers, codeBundleCache),
+        createBrowserCodeBundleOptions(options, target, browsers, codeBundleCache),
       ),
     );
 
@@ -93,6 +95,25 @@ export async function executeBuild(
         }
       }
     }
+
+    // Server application code
+    if (serverEntryPoint) {
+      bundlerContexts.push(
+        new BundlerContext(
+          workspaceRoot,
+          !!options.watch,
+          createServerCodeBundleOptions(
+            options,
+            // NOTE: earlier versions of Node.js are not supported due to unsafe promise patching.
+            // See: https://github.com/angular/angular/pull/50552#issue-1737967592
+            [...target, 'node18.13'],
+            browsers,
+            codeBundleCache,
+          ),
+          () => false,
+        ),
+      );
+    }
   }
 
   const bundlingResult = await BundlerContext.bundleAll(bundlerContexts);

packages/angular_devkit/build_angular/src/builders/application/options.ts

@@ -25,7 +25,7 @@ export type NormalizedApplicationBuildOptions = Awaited<ReturnType<typeof normal
 /** Internal options hidden from builder schema but available when invoked programmatically. */
 interface InternalOptions {
   /**
-   * Entry points to use for the compilation. Incompatible with `main`, which must not be provided. May be relative or absolute paths.
+   * Entry points to use for the compilation. Incompatible with `browser`, which must not be provided. May be relative or absolute paths.
    * If given a relative path, it is resolved relative to the current workspace and will generate an output at the same relative location
    * in the output directory. If given an absolute path, the output will be generated in the root of the output directory with the same base
    * name.
@@ -42,7 +42,7 @@ interface InternalOptions {
   externalPackages?: boolean;
 }
 
-/** Full set of options for `browser-esbuild` builder. */
+/** Full set of options for `application` builder. */
 export type ApplicationBuilderInternalOptions = Omit<
   ApplicationBuilderOptions & InternalOptions,
   'browser'
@@ -164,6 +164,13 @@ export async function normalizeOptions(
     };
   }
 
+  let serverEntryPoint: string | undefined;
+  if (options.server) {
+    serverEntryPoint = path.join(workspaceRoot, options.server);
+  } else if (options.server === '') {
+    throw new Error('`server` option cannot be an empty string.');
+  }
+
   // Initial options to keep
   const {
     allowedCommonJsDependencies,
@@ -182,7 +189,6 @@ export async function normalizeOptions(
     stylePreprocessorOptions,
     subresourceIntegrity,
     verbose,
-    server,
     watch,
     progress = true,
     externalPackages,
@@ -210,7 +216,7 @@ export async function normalizeOptions(
     preserveSymlinks: preserveSymlinks ?? process.execArgv.includes('--preserve-symlinks'),
     stylePreprocessorOptions,
     subresourceIntegrity,
-    server: !!server && path.join(workspaceRoot, server),
+    serverEntryPoint,
     verbose,
     watch,
     workspaceRoot,
@@ -233,39 +239,39 @@ export async function normalizeOptions(
 }
 
 /**
- * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `main` option which defines a
- * single entry point. However, we also want to support multiple entry points as an internal option. The two options are mutually exclusive
- * and if `main` is provided it will be used as the sole entry point. If `entryPoints` are provided, they will be used as the set of entry
- * points.
+ * Normalize entry point options. To maintain compatibility with the legacy browser builder, we need a single `browser`
+ * option which defines a single entry point. However, we also want to support multiple entry points as an internal option.
+ * The two options are mutually exclusive and if `browser` is provided it will be used as the sole entry point.
+ * If `entryPoints` are provided, they will be used as the set of entry points.
  *
  * @param workspaceRoot Path to the root of the Angular workspace.
- * @param main The `main` option pointing at the application entry point. While required per the schema file, it may be omitted by
+ * @param browser The `browser` option pointing at the application entry point. While required per the schema file, it may be omitted by
  *     programmatic usages of `browser-esbuild`.
  * @param entryPoints Set of entry points to use if provided.
  * @returns An object mapping entry point names to their file paths.
  */
 function normalizeEntryPoints(
   workspaceRoot: string,
-  main: string | undefined,
+  browser: string | undefined,
   entryPoints: Set<string> = new Set(),
 ): Record<string, string> {
-  if (main === '') {
-    throw new Error('`main` option cannot be an empty string.');
+  if (browser === '') {
+    throw new Error('`browser` option cannot be an empty string.');
   }
 
-  // `main` and `entryPoints` are mutually exclusive.
-  if (main && entryPoints.size > 0) {
-    throw new Error('Only one of `main` or `entryPoints` may be provided.');
+  // `browser` and `entryPoints` are mutually exclusive.
+  if (browser && entryPoints.size > 0) {
+    throw new Error('Only one of `browser` or `entryPoints` may be provided.');
   }
-  if (!main && entryPoints.size === 0) {
+  if (!browser && entryPoints.size === 0) {
     // Schema should normally reject this case, but programmatic usages of the builder might make this mistake.
-    throw new Error('Either `main` or at least one `entryPoints` value must be provided.');
+    throw new Error('Either `browser` or at least one `entryPoints` value must be provided.');
   }
 
-  // Schema types force `main` to always be provided, but it may be omitted when the builder is invoked programmatically.
-  if (main) {
-    // Use `main` alone.
-    return { 'main': path.join(workspaceRoot, main) };
+  // Schema types force `browser` to always be provided, but it may be omitted when the builder is invoked programmatically.
+  if (browser) {
+    // Use `browser` alone.
+    return { 'main': path.join(workspaceRoot, browser) };
   } else {
     // Use `entryPoints` alone.
     const entryPointPaths: Record<string, string> = {};

packages/angular_devkit/build_angular/src/builders/application/tests/options/browser_spec.ts

@@ -66,7 +66,7 @@ describeBuilder(buildApplication, APPLICATION_BUILDER_INFO, (harness) => {
         browser: '',
       });
 
-      const { result, error } = await harness.executeOnce();
+      const { result, error } = await harness.executeOnce({ outputLogsOnException: false });
       expect(result).toBeUndefined();
 
       expect(error?.message).toContain('cannot be an empty string');

packages/angular_devkit/build_angular/src/builders/application/tests/options/server_spec.ts

@@ -0,0 +1,95 @@
+/**
+ * @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.io/license
+ */
+
+import { buildApplication } from '../../index';
+import { APPLICATION_BUILDER_INFO, BASE_OPTIONS, describeBuilder } from '../setup';
+
+describeBuilder(buildApplication, APPLICATION_BUILDER_INFO, (harness) => {
+  beforeEach(async () => {
+    await harness.modifyFile('src/tsconfig.app.json', (content) => {
+      const tsConfig = JSON.parse(content);
+      tsConfig.files ??= [];
+      tsConfig.files.push('main.server.ts');
+
+      return JSON.stringify(tsConfig);
+    });
+  });
+
+  describe('Option: "server"', () => {
+    it('uses a provided TypeScript file', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        server: 'src/main.server.ts',
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      harness.expectFile('dist/server.mjs').toExist();
+      harness.expectFile('dist/main.js').toExist();
+    });
+
+    it('uses a provided JavaScript file', async () => {
+      await harness.writeFile('src/server.js', `console.log('server');`);
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        server: 'src/server.js',
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      harness.expectFile('dist/server.mjs').content.toContain('console.log("server")');
+    });
+
+    it('fails and shows an error when file does not exist', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        server: 'src/missing.ts',
+      });
+
+      const { result, logs } = await harness.executeOnce({ outputLogsOnFailure: false });
+
+      expect(result?.success).toBeFalse();
+      expect(logs).toContain(
+        jasmine.objectContaining({ message: jasmine.stringMatching('Could not resolve "') }),
+      );
+
+      harness.expectFile('dist/main.js').toNotExist();
+      harness.expectFile('dist/server.mjs').toNotExist();
+    });
+
+    it('throws an error when given an empty string', async () => {
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        server: '',
+      });
+
+      const { result, error } = await harness.executeOnce({ outputLogsOnException: false });
+      expect(result).toBeUndefined();
+
+      expect(error?.message).toContain('cannot be an empty string');
+    });
+
+    it('resolves an absolute path as relative inside the workspace root', async () => {
+      await harness.writeFile('file.mjs', `console.log('Hello!');`);
+
+      harness.useTarget('build', {
+        ...BASE_OPTIONS,
+        server: '/file.mjs',
+      });
+
+      const { result } = await harness.executeOnce();
+      expect(result?.success).toBeTrue();
+
+      // Always uses the name `server.mjs` for the `server` option.
+      harness.expectFile('dist/server.mjs').toExist();
+    });
+  });
+});

packages/angular_devkit/build_angular/src/builders/browser-esbuild/tests/options/main_spec.ts

@@ -66,7 +66,7 @@ describeBuilder(buildEsbuildBrowser, BROWSER_BUILDER_INFO, (harness) => {
         main: '',
       });
 
-      const { result, error } = await harness.executeOnce();
+      const { result, error } = await harness.executeOnce({ outputLogsOnException: false });
       expect(result).toBeUndefined();
 
       expect(error?.message).toContain('cannot be an empty string');

packages/angular_devkit/build_angular/src/tools/esbuild/angular/angular-compilation.ts packages/angular_devkit/build_angular/src/tools/esbuild/angular/compilation/angular-compilation.ts

@@ -8,9 +8,9 @@
 
 import type ng from '@angular/compiler-cli';
 import type ts from 'typescript';
-import { loadEsmModule } from '../../../utils/load-esm';
-import { profileSync } from '../profiling';
-import type { AngularHostOptions } from './angular-host';
+import { loadEsmModule } from '../../../../utils/load-esm';
+import { profileSync } from '../../profiling';
+import type { AngularHostOptions } from '../angular-host';
 
 export interface EmitFileResult {
   filename: string;

packages/angular_devkit/build_angular/src/tools/esbuild/angular/aot-compilation.ts packages/angular_devkit/build_angular/src/tools/esbuild/angular/compilation/aot-compilation.ts

@@ -9,13 +9,13 @@
 import type ng from '@angular/compiler-cli';
 import assert from 'node:assert';
 import ts from 'typescript';
-import { profileAsync, profileSync } from '../profiling';
-import { AngularCompilation, EmitFileResult } from './angular-compilation';
+import { profileAsync, profileSync } from '../../profiling';
 import {
   AngularHostOptions,
   createAngularCompilerHost,
   ensureSourceFileVersions,
-} from './angular-host';
+} from '../angular-host';
+import { AngularCompilation, EmitFileResult } from './angular-compilation';
 
 // Temporary deep import for transformer support
 // TODO: Move these to a private exports location or move the implementation into this package.

packages/angular_devkit/build_angular/src/tools/esbuild/angular/jit-compilation.ts packages/angular_devkit/build_angular/src/tools/esbuild/angular/compilation/jit-compilation.ts

@@ -9,10 +9,10 @@
 import type ng from '@angular/compiler-cli';
 import assert from 'node:assert';
 import ts from 'typescript';
-import { profileSync } from '../profiling';
+import { profileSync } from '../../profiling';
+import { AngularHostOptions, createAngularCompilerHost } from '../angular-host';
+import { createJitResourceTransformer } from '../jit-resource-transformer';
 import { AngularCompilation, EmitFileResult } from './angular-compilation';
-import { AngularHostOptions, createAngularCompilerHost } from './angular-host';
-import { createJitResourceTransformer } from './jit-resource-transformer';
 
 class JitCompilationState {
   constructor(

packages/angular_devkit/build_angular/src/tools/esbuild/angular/compilation/noop-compilation.ts

@@ -0,0 +1,39 @@
+/**
+ * @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.io/license
+ */
+
+import type ng from '@angular/compiler-cli';
+import ts from 'typescript';
+import { AngularHostOptions } from '../angular-host';
+import { AngularCompilation } from './angular-compilation';
+
+export class NoopCompilation extends AngularCompilation {
+  async initialize(
+    tsconfig: string,
+    hostOptions: AngularHostOptions,
+    compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions,
+  ): Promise<{
+    affectedFiles: ReadonlySet<ts.SourceFile>;
+    compilerOptions: ng.CompilerOptions;
+    referencedFiles: readonly string[];
+  }> {
+    // Load the compiler configuration and transform as needed
+    const { options: originalCompilerOptions } = await this.loadConfiguration(tsconfig);
+    const compilerOptions =
+      compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
+
+    return { affectedFiles: new Set(), compilerOptions, referencedFiles: [] };
+  }
+
+  collectDiagnostics(): never {
+    throw new Error('Not available when using noop compilation.');
+  }
+
+  emitAffectedFiles(): never {
+    throw new Error('Not available when using noop compilation.');
+  }
+}

packages/angular_devkit/build_angular/src/tools/esbuild/angular/compiler-plugin.ts

@@ -29,11 +29,12 @@ import {
   resetCumulativeDurations,
 } from '../profiling';
 import { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets/bundle-options';
-import { AngularCompilation } from './angular-compilation';
 import { AngularHostOptions } from './angular-host';
-import { AotCompilation } from './aot-compilation';
+import { AngularCompilation } from './compilation/angular-compilation';
+import { AotCompilation } from './compilation/aot-compilation';
+import { JitCompilation } from './compilation/jit-compilation';
+import { NoopCompilation } from './compilation/noop-compilation';
 import { convertTypeScriptDiagnostic } from './diagnostics';
-import { JitCompilation } from './jit-compilation';
 import { setupJitPluginCallbacks } from './jit-plugin-callbacks';
 
 const USING_WINDOWS = platform() === 'win32';
@@ -73,18 +74,31 @@ export interface CompilerPluginOptions {
   sourcemap: boolean;
   tsconfig: string;
   jit?: boolean;
+  /** Skip TypeScript compilation setup. This is useful to re-use the TypeScript compilation from another plugin. */
+  noopTypeScriptCompilation?: boolean;
   advancedOptimizations?: boolean;
   thirdPartySourcemaps?: boolean;
   fileReplacements?: Record<string, string>;
   sourceFileCache?: SourceFileCache;
   loadResultCache?: LoadResultCache;
 }
 
+// TODO: find a better way to unblock TS compilation of server bundles.
+let TS_COMPILATION_READY: Promise<void> | undefined;
+
 // eslint-disable-next-line max-lines-per-function
 export function createCompilerPlugin(
   pluginOptions: CompilerPluginOptions,
   styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },
 ): Plugin {
+  let resolveCompilationReady: (() => void) | undefined;
+
+  if (!pluginOptions.noopTypeScriptCompilation) {
+    TS_COMPILATION_READY = new Promise<void>((resolve) => {
+      resolveCompilationReady = resolve;
+    });
+  }
+
   return {
     name: 'angular-compiler',
     // eslint-disable-next-line max-lines-per-function
@@ -132,7 +146,9 @@ export function createCompilerPlugin(
       let stylesheetMetafiles: Metafile[];
 
       // Create new reusable compilation for the appropriate mode based on the `jit` plugin option
-      const compilation: AngularCompilation = pluginOptions.jit
+      const compilation: AngularCompilation = pluginOptions.noopTypeScriptCompilation
+        ? new NoopCompilation()
+        : pluginOptions.jit
         ? new JitCompilation()
         : new AotCompilation();
 
@@ -239,6 +255,12 @@ export function createCompilerPlugin(
         });
         shouldTsIgnoreJs = !allowJs;
 
+        if (compilation instanceof NoopCompilation) {
+          await TS_COMPILATION_READY;
+
+          return result;
+        }
+
         profileSync('NG_DIAGNOSTICS_TOTAL', () => {
           for (const diagnostic of compilation.collectDiagnostics()) {
             const message = convertTypeScriptDiagnostic(diagnostic);
@@ -265,6 +287,9 @@ export function createCompilerPlugin(
         // Reset the setup warnings so that they are only shown during the first build.
         setupWarnings = undefined;
 
+        // TODO: find a better way to unblock TS compilation of server bundles.
+        resolveCompilationReady?.();
+
         return result;
       });
 

packages/angular_devkit/build_angular/src/tools/esbuild/application-code-bundle.ts

@@ -0,0 +1,89 @@
+/**
+ * @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.io/license
+ */
+
+import type { BuildOptions } from 'esbuild';
+import type { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { SourceFileCache, createCompilerPlugin } from './angular/compiler-plugin';
+import { createCompilerPluginOptions } from './compiler-plugin';
+import { createExternalPackagesPlugin } from './external-packages-plugin';
+import { createSourcemapIngorelistPlugin } from './sourcemap-ignorelist-plugin';
+import {
+  getEsBuildCommonOptions as getEsBuildCodeBundleCommonOptions,
+  getFeatureSupport,
+} from './utils';
+import { createVirtualModulePlugin } from './virtual-module-plugin';
+
+export function createBrowserCodeBundleOptions(
+  options: NormalizedApplicationBuildOptions,
+  target: string[],
+  browsers: string[],
+  sourceFileCache?: SourceFileCache,
+): BuildOptions {
+  const { workspaceRoot, entryPoints, outputNames, jit } = options;
+
+  const { pluginOptions, styleOptions } = createCompilerPluginOptions(
+    options,
+    target,
+    browsers,
+    sourceFileCache,
+  );
+
+  const buildOptions: BuildOptions = {
+    ...getEsBuildCodeBundleCommonOptions(options),
+    platform: 'browser',
+    // 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
+    // runtime with the RxJS testing library.
+    // More details: https://github.com/angular/angular-cli/issues/25405.
+    mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
+    entryNames: outputNames.bundles,
+    entryPoints,
+    target,
+    supported: getFeatureSupport(target),
+    plugins: [
+      createSourcemapIngorelistPlugin(),
+      createCompilerPlugin(
+        // JS/TS options
+        pluginOptions,
+        // Component stylesheet options
+        styleOptions,
+      ),
+    ],
+  };
+
+  if (options.externalPackages) {
+    buildOptions.plugins ??= [];
+    buildOptions.plugins.push(createExternalPackagesPlugin());
+  }
+
+  const polyfills = options.polyfills ? [...options.polyfills] : [];
+  if (jit) {
+    polyfills.push('@angular/compiler');
+  }
+
+  if (polyfills?.length) {
+    const namespace = 'angular:polyfills';
+    buildOptions.entryPoints = {
+      ...buildOptions.entryPoints,
+      'polyfills': namespace,
+    };
+
+    buildOptions.plugins?.unshift(
+      createVirtualModulePlugin({
+        namespace,
+        loadContent: () => ({
+          contents: polyfills.map((file) => `import '${file.replace(/\\/g, '/')}';`).join('\n'),
+          loader: 'js',
+          resolveDir: workspaceRoot,
+        }),
+      }),
+    );
+  }
+
+  return buildOptions;
+}

packages/angular_devkit/build_angular/src/tools/esbuild/browser-code-bundle.ts

@@ -0,0 +1,70 @@
+/**
+ * @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.io/license
+ */
+
+import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import type { SourceFileCache, createCompilerPlugin } from './angular/compiler-plugin';
+
+type CreateCompilerPluginParameters = Parameters<typeof createCompilerPlugin>;
+
+export function createCompilerPluginOptions(
+  options: NormalizedApplicationBuildOptions,
+  target: string[],
+  browsers: string[],
+  sourceFileCache?: SourceFileCache,
+): {
+  pluginOptions: CreateCompilerPluginParameters[0];
+  styleOptions: CreateCompilerPluginParameters[1];
+} {
+  const {
+    workspaceRoot,
+    optimizationOptions,
+    sourcemapOptions,
+    tsconfig,
+    outputNames,
+    fileReplacements,
+    externalDependencies,
+    preserveSymlinks,
+    stylePreprocessorOptions,
+    advancedOptimizations,
+    inlineStyleLanguage,
+    jit,
+    tailwindConfiguration,
+  } = options;
+
+  return {
+    // JS/TS options
+    pluginOptions: {
+      sourcemap: !!sourcemapOptions.scripts,
+      thirdPartySourcemaps: sourcemapOptions.vendor,
+      tsconfig,
+      jit,
+      advancedOptimizations,
+      fileReplacements,
+      sourceFileCache,
+      loadResultCache: sourceFileCache?.loadResultCache,
+    },
+    // Component stylesheet options
+    styleOptions: {
+      workspaceRoot,
+      optimization: !!optimizationOptions.styles.minify,
+      sourcemap:
+        // Hidden component stylesheet sourcemaps are inaccessible which is effectively
+        // the same as being disabled. Disabling has the advantage of avoiding the overhead
+        // of sourcemap processing.
+        !!sourcemapOptions.styles && (sourcemapOptions.hidden ? false : 'inline'),
+      outputNames,
+      includePaths: stylePreprocessorOptions?.includePaths,
+      externalDependencies,
+      target,
+      inlineStyleLanguage,
+      preserveSymlinks,
+      browsers,
+      tailwindConfiguration,
+    },
+  };
+}

packages/angular_devkit/build_angular/src/tools/esbuild/compiler-plugin.ts

@@ -0,0 +1,107 @@
+/**
+ * @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.io/license
+ */
+
+import type { BuildOptions } from 'esbuild';
+import assert from 'node:assert';
+import path from 'node:path';
+import type { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { SourceFileCache, createCompilerPlugin } from './angular/compiler-plugin';
+import { createCompilerPluginOptions } from './compiler-plugin';
+import { createExternalPackagesPlugin } from './external-packages-plugin';
+import { createSourcemapIngorelistPlugin } from './sourcemap-ignorelist-plugin';
+import { getEsBuildCommonOptions, getFeatureSupport } from './utils';
+import { createVirtualModulePlugin } from './virtual-module-plugin';
+
+/**
+ * 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 function createServerCodeBundleOptions(
+  options: NormalizedApplicationBuildOptions,
+  target: string[],
+  browsers: string[],
+  sourceFileCache: SourceFileCache,
+): BuildOptions {
+  const { jit, serverEntryPoint, workspaceRoot } = options;
+
+  assert(
+    serverEntryPoint,
+    'createServerCodeBundleOptions should not be called without a defined serverEntryPoint.',
+  );
+
+  const { pluginOptions, styleOptions } = createCompilerPluginOptions(
+    options,
+    target,
+    browsers,
+    sourceFileCache,
+  );
+
+  const namespace = 'angular:server-entry';
+
+  const buildOptions: BuildOptions = {
+    ...getEsBuildCommonOptions(options),
+    platform: 'node',
+    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
+    // runtime with the RxJS testing library.
+    // More details: https://github.com/angular/angular-cli/issues/25405.
+    mainFields: ['es2020', 'es2015', 'module', 'main'],
+    entryNames: '[name]',
+    target,
+    banner: {
+      // Note: Needed as esbuild does not provide require shims / proxy from ESModules.
+      // See: https://github.com/evanw/esbuild/issues/1921.
+      js: [
+        `import { createRequire } from 'node:module';`,
+        `globalThis['require'] ??= createRequire(import.meta.url);`,
+      ].join('\n'),
+    },
+    entryPoints: {
+      'server': namespace,
+    },
+    supported: getFeatureSupport(target),
+    plugins: [
+      createSourcemapIngorelistPlugin(),
+      createCompilerPlugin(
+        // JS/TS options
+        { ...pluginOptions, noopTypeScriptCompilation: true },
+        // Component stylesheet options
+        styleOptions,
+      ),
+      createVirtualModulePlugin({
+        namespace,
+        loadContent: () => {
+          const importAndExportDec: string[] = [
+            `import '@angular/platform-server/init';`,
+            `import './${path.relative(workspaceRoot, serverEntryPoint).replace(/\\/g, '/')}';`,
+            `export { renderApplication, renderModule, ɵSERVER_CONTEXT } from '@angular/platform-server';`,
+          ];
+
+          if (jit) {
+            importAndExportDec.unshift(`import '@angular/compiler';`);
+          }
+
+          return {
+            contents: importAndExportDec.join('\n'),
+            loader: 'js',
+            resolveDir: workspaceRoot,
+          };
+        },
+      }),
+    ],
+  };
+
+  if (options.externalPackages) {
+    buildOptions.plugins ??= [];
+    buildOptions.plugins.push(createExternalPackagesPlugin());
+  }
+
+  return buildOptions;
+}

packages/angular_devkit/build_angular/src/tools/esbuild/server-code-bundle.ts

@@ -13,6 +13,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { brotliCompress } from 'node:zlib';
+import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { allowMangle } from '../../utils/environment-options';
 import { Spinner } from '../../utils/spinner';
 import { BundleStats, generateBuildStatsTable } from '../webpack/utils/stats';
 import { InitialFileRecord } from './bundler-context';
@@ -256,3 +258,48 @@ export function transformSupportedBrowsersToTargets(supportedBrowsers: string[])
 
   return transformed;
 }
+
+export function getEsBuildCommonOptions(options: NormalizedApplicationBuildOptions): BuildOptions {
+  const {
+    workspaceRoot,
+    outExtension,
+    optimizationOptions,
+    sourcemapOptions,
+    tsconfig,
+    externalDependencies,
+    outputNames,
+    preserveSymlinks,
+    jit,
+  } = options;
+
+  return {
+    absWorkingDir: workspaceRoot,
+    bundle: true,
+    format: 'esm',
+    assetNames: outputNames.media,
+    conditions: ['es2020', 'es2015', 'module'],
+    resolveExtensions: ['.ts', '.tsx', '.mjs', '.js'],
+    metafile: true,
+    legalComments: options.extractLicenses ? 'none' : 'eof',
+    logLevel: options.verbose ? 'debug' : 'silent',
+    minifyIdentifiers: optimizationOptions.scripts && allowMangle,
+    minifySyntax: optimizationOptions.scripts,
+    minifyWhitespace: optimizationOptions.scripts,
+    pure: ['forwardRef'],
+    outdir: workspaceRoot,
+    outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined,
+    sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
+    splitting: true,
+    tsconfig,
+    external: externalDependencies,
+    write: false,
+    preserveSymlinks,
+    define: {
+      // Only set to false when script optimizations are enabled. It should not be set to true because
+      // Angular turns `ngDevMode` into an object for development debugging purposes when not defined
+      // which a constant true value would break.
+      ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),
+      'ngJitMode': jit ? 'true' : 'false',
+    },
+  };
+}