@angular-devkit/build-angular 17.0.0-rc.2 → 17.0.0-rc.4

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

@@ -78,6 +78,8 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
             const compilation = pluginOptions.noopTypeScriptCompilation
                 ? new compilation_1.NoopCompilation()
                 : await (0, compilation_1.createAngularCompilation)(!!pluginOptions.jit);
+            // Compilation is initially assumed to have errors until emitted
+            let hasCompilationErrors = true;
             // Determines if TypeScript should process JavaScript files based on tsconfig `allowJs` option
             let shouldTsIgnoreJs = true;
             // Track incremental component stylesheet builds
@@ -172,77 +174,64 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                         // Return bundled worker file entry name to be used in the built output
                         const workerCodeFile = workerResult.outputFiles.find((file) => file.path.endsWith('.js'));
                         (0, node_assert_1.default)(workerCodeFile, 'Web Worker bundled code file should always be present.');
-                        return path.relative(build.initialOptions.outdir ?? '', workerCodeFile.path);
+                        const workerCodePath = path.relative(build.initialOptions.outdir ?? '', workerCodeFile.path);
+                        return workerCodePath.replaceAll('\\', '/');
                     },
                 };
                 // Initialize the Angular compilation for the current build.
                 // In watch mode, previous build state will be reused.
-                const { compilerOptions: { allowJs }, referencedFiles, } = await compilation.initialize(tsconfigPath, hostOptions, (compilerOptions) => {
-                    // target of 9 is ES2022 (using the number avoids an expensive import of typescript just for an enum)
-                    if (compilerOptions.target === undefined || compilerOptions.target < 9) {
-                        // If 'useDefineForClassFields' is already defined in the users project leave the value as is.
-                        // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995
-                        // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well.
-                        compilerOptions.target = 9;
-                        compilerOptions.useDefineForClassFields ??= false;
-                        // Only add the warning on the initial build
-                        setupWarnings?.push({
-                            text: 'TypeScript compiler options "target" and "useDefineForClassFields" are set to "ES2022" and ' +
-                                '"false" respectively by the Angular CLI.',
-                            location: { file: pluginOptions.tsconfig },
-                            notes: [
-                                {
-                                    text: 'To control ECMA version and features use the Browerslist configuration. ' +
-                                        'For more information, see https://angular.io/guide/build#configuring-browser-compatibility',
-                                },
-                            ],
-                        });
-                    }
-                    if (compilerOptions.compilationMode === 'partial') {
-                        setupWarnings?.push({
-                            text: 'Angular partial compilation mode is not supported when building applications.',
-                            location: null,
-                            notes: [{ text: 'Full compilation mode will be used instead.' }],
-                        });
-                        compilerOptions.compilationMode = 'full';
-                    }
-                    // Enable incremental compilation by default if caching is enabled
-                    if (pluginOptions.sourceFileCache?.persistentCachePath) {
-                        compilerOptions.incremental ??= true;
-                        // Set the build info file location to the configured cache directory
-                        compilerOptions.tsBuildInfoFile = path.join(pluginOptions.sourceFileCache?.persistentCachePath, '.tsbuildinfo');
-                    }
-                    else {
-                        compilerOptions.incremental = false;
-                    }
-                    return {
-                        ...compilerOptions,
-                        noEmitOnError: false,
-                        inlineSources: pluginOptions.sourcemap,
-                        inlineSourceMap: pluginOptions.sourcemap,
-                        mapRoot: undefined,
-                        sourceRoot: undefined,
-                        preserveSymlinks,
-                    };
-                });
-                shouldTsIgnoreJs = !allowJs;
+                let referencedFiles;
+                try {
+                    const initializationResult = await compilation.initialize(tsconfigPath, hostOptions, createCompilerOptionsTransformer(setupWarnings, pluginOptions, preserveSymlinks));
+                    shouldTsIgnoreJs = !initializationResult.compilerOptions.allowJs;
+                    referencedFiles = initializationResult.referencedFiles;
+                }
+                catch (error) {
+                    (result.errors ??= []).push({
+                        text: 'Angular compilation initialization failed.',
+                        location: null,
+                        notes: [
+                            {
+                                text: error instanceof Error ? error.stack ?? error.message : `${error}`,
+                                location: null,
+                            },
+                        ],
+                    });
+                    // Initialization failure prevents further compilation steps
+                    hasCompilationErrors = true;
+                    return result;
+                }
                 if (compilation instanceof compilation_1.NoopCompilation) {
                     await sharedTSCompilationState.waitUntilReady;
                     return result;
                 }
                 const diagnostics = await compilation.diagnoseFiles();
-                if (diagnostics.errors) {
+                if (diagnostics.errors?.length) {
                     (result.errors ??= []).push(...diagnostics.errors);
                 }
-                if (diagnostics.warnings) {
+                if (diagnostics.warnings?.length) {
                     (result.warnings ??= []).push(...diagnostics.warnings);
                 }
                 // Update TypeScript file output cache for all affected files
-                await (0, profiling_1.profileAsync)('NG_EMIT_TS', async () => {
-                    for (const { filename, contents } of await compilation.emitAffectedFiles()) {
-                        typeScriptFileCache.set((0, node_url_1.pathToFileURL)(filename).href, contents);
-                    }
-                });
+                try {
+                    await (0, profiling_1.profileAsync)('NG_EMIT_TS', async () => {
+                        for (const { filename, contents } of await compilation.emitAffectedFiles()) {
+                            typeScriptFileCache.set((0, node_url_1.pathToFileURL)(filename).href, contents);
+                        }
+                    });
+                }
+                catch (error) {
+                    (result.errors ??= []).push({
+                        text: 'Angular compilation emit failed.',
+                        location: null,
+                        notes: [
+                            {
+                                text: error instanceof Error ? error.stack ?? error.message : `${error}`,
+                                location: null,
+                            },
+                        ],
+                    });
+                }
                 // Add errors from failed additional results.
                 // This must be done after emit to capture latest web worker results.
                 for (const { errors } of additionalResults.values()) {
@@ -257,6 +246,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                         ...referencedFileTracker.referencedFiles,
                     ];
                 }
+                hasCompilationErrors = !!result.errors?.length;
                 // Reset the setup warnings so that they are only shown during the first build.
                 setupWarnings = undefined;
                 sharedTSCompilationState.markAsReady();
@@ -274,6 +264,11 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                 // would need to be added to the key as well as a check for any change of content.
                 let contents = typeScriptFileCache.get((0, node_url_1.pathToFileURL)(request).href);
                 if (contents === undefined) {
+                    // If the Angular compilation had errors the file may not have been emitted.
+                    // To avoid additional errors about missing files, return empty contents.
+                    if (hasCompilationErrors) {
+                        return { contents: '', loader: 'js' };
+                    }
                     // No TS result indicates the file is not part of the TypeScript program.
                     // If allowJs is enabled and the file is JS then defer to the next load hook.
                     if (!shouldTsIgnoreJs && /\.[cm]?js$/.test(request)) {
@@ -317,6 +312,8 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                 (0, jit_plugin_callbacks_1.setupJitPluginCallbacks)(build, stylesheetBundler, additionalResults, styleOptions.inlineStyleLanguage);
             }
             build.onEnd((result) => {
+                // Ensure other compilations are unblocked if the main compilation throws during start
+                sharedTSCompilationState?.markAsReady();
                 for (const { outputFiles, metafile } of additionalResults.values()) {
                     // Add any additional output files to the main output files
                     if (outputFiles?.length) {
@@ -339,6 +336,56 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
     };
 }
 exports.createCompilerPlugin = createCompilerPlugin;
+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)
+        if (compilerOptions.target === undefined || compilerOptions.target < 9) {
+            // If 'useDefineForClassFields' is already defined in the users project leave the value as is.
+            // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995
+            // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well.
+            compilerOptions.target = 9;
+            compilerOptions.useDefineForClassFields ??= false;
+            // Only add the warning on the initial build
+            setupWarnings?.push({
+                text: 'TypeScript compiler options "target" and "useDefineForClassFields" are set to "ES2022" and ' +
+                    '"false" respectively by the Angular CLI.',
+                location: { file: pluginOptions.tsconfig },
+                notes: [
+                    {
+                        text: 'To control ECMA version and features use the Browerslist configuration. ' +
+                            'For more information, see https://angular.io/guide/build#configuring-browser-compatibility',
+                    },
+                ],
+            });
+        }
+        if (compilerOptions.compilationMode === 'partial') {
+            setupWarnings?.push({
+                text: 'Angular partial compilation mode is not supported when building applications.',
+                location: null,
+                notes: [{ text: 'Full compilation mode will be used instead.' }],
+            });
+            compilerOptions.compilationMode = 'full';
+        }
+        // Enable incremental compilation by default if caching is enabled
+        if (pluginOptions.sourceFileCache?.persistentCachePath) {
+            compilerOptions.incremental ??= true;
+            // Set the build info file location to the configured cache directory
+            compilerOptions.tsBuildInfoFile = path.join(pluginOptions.sourceFileCache?.persistentCachePath, '.tsbuildinfo');
+        }
+        else {
+            compilerOptions.incremental = false;
+        }
+        return {
+            ...compilerOptions,
+            noEmitOnError: false,
+            inlineSources: pluginOptions.sourcemap,
+            inlineSourceMap: pluginOptions.sourcemap,
+            mapRoot: undefined,
+            sourceRoot: undefined,
+            preserveSymlinks,
+        };
+    };
+}
 function bundleWebWorker(build, pluginOptions, workerFile) {
     try {
         return build.esbuild.buildSync({

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

@@ -8,12 +8,13 @@
 import type { BuildOptions } from 'esbuild';
 import type { NormalizedApplicationBuildOptions } from '../../builders/application/options';
 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 | undefined;
+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): BuildOptions | undefined;
+export declare function createServerPolyfillBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): BundlerOptionsFactory | undefined;

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

@@ -63,6 +63,7 @@ function createBrowserPolyfillBundleOptions(options, target, sourceFileCache) {
         return;
     }
     const { outputNames, polyfills } = options;
+    const hasTypeScriptEntries = polyfills?.some((entry) => /\.[cm]?tsx?$/.test(entry));
     const buildOptions = {
         ...polyfillBundleOptions,
         platform: 'browser',
@@ -78,7 +79,6 @@ function createBrowserPolyfillBundleOptions(options, target, sourceFileCache) {
         },
     };
     // Only add the Angular TypeScript compiler if TypeScript files are provided in the polyfills
-    const hasTypeScriptEntries = polyfills?.some((entry) => /\.[cm]?tsx?$/.test(entry));
     if (hasTypeScriptEntries) {
         buildOptions.plugins ??= [];
         const { pluginOptions, styleOptions } = (0, compiler_plugin_options_1.createCompilerPluginOptions)(options, target, sourceFileCache);
@@ -88,7 +88,10 @@ function createBrowserPolyfillBundleOptions(options, target, sourceFileCache) {
         // Component stylesheet options are unused for polyfills but required by the plugin
         styleOptions));
     }
-    return buildOptions;
+    // Use an options factory to allow fully incremental bundling when no TypeScript files are present.
+    // The TypeScript compilation is not currently integrated into the bundler invalidation so
+    // cannot be used with fully incremental bundling yet.
+    return hasTypeScriptEntries ? buildOptions : () => buildOptions;
 }
 exports.createBrowserPolyfillBundleOptions = createBrowserPolyfillBundleOptions;
 /**
@@ -174,12 +177,9 @@ function createServerCodeBundleOptions(options, target, sourceFileCache) {
 exports.createServerCodeBundleOptions = createServerCodeBundleOptions;
 function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
     const polyfills = [];
-    const zoneFlagsNamespace = 'angular:zone-flags/placeholder';
     const polyfillsFromConfig = new Set(options.polyfills);
-    let hasZoneJs = false;
     if (polyfillsFromConfig.has('zone.js')) {
-        hasZoneJs = true;
-        polyfills.push(zoneFlagsNamespace, 'zone.js/node');
+        polyfills.push('zone.js/node');
     }
     if (polyfillsFromConfig.has('@angular/localize') ||
         polyfillsFromConfig.has('@angular/localize/init')) {
@@ -219,20 +219,8 @@ function createServerPolyfillBundleOptions(options, target, sourceFileCache) {
         },
     };
     buildOptions.plugins ??= [];
-    // Disable Zone.js uncaught promise rejections to provide cleaner stacktraces.
-    if (hasZoneJs) {
-        buildOptions.plugins.unshift((0, virtual_module_plugin_1.createVirtualModulePlugin)({
-            namespace: zoneFlagsNamespace,
-            entryPointOnly: false,
-            loadContent: () => ({
-                contents: `globalThis.__zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION = true;`,
-                loader: 'js',
-                resolveDir: workspaceRoot,
-            }),
-        }));
-    }
     buildOptions.plugins.push((0, rxjs_esm_resolution_plugin_1.createRxjsEsmResolutionPlugin)());
-    return buildOptions;
+    return () => buildOptions;
 }
 exports.createServerPolyfillBundleOptions = createServerPolyfillBundleOptions;
 function getEsBuildCommonOptions(options) {

package/src/tools/esbuild/bundler-context.d.ts

@@ -16,7 +16,10 @@ export type BundleContextResult = {
     metafile: Metafile;
     outputFiles: BuildOutputFile[];
     initialFiles: Map<string, InitialFileRecord>;
-    externalImports: Set<string>;
+    externalImports: {
+        server?: Set<string>;
+        browser?: Set<string>;
+    };
 };
 export interface InitialFileRecord {
     entrypoint: boolean;

package/src/tools/esbuild/bundler-context.js

@@ -68,7 +68,8 @@ class BundlerContext {
         const warnings = [];
         const metafile = { inputs: {}, outputs: {} };
         const initialFiles = new Map();
-        const externalImports = new Set();
+        const externalImportsBrowser = new Set();
+        const externalImportsServer = new Set();
         const outputFiles = [];
         for (const result of individualResults) {
             warnings.push(...result.warnings);
@@ -84,7 +85,8 @@ class BundlerContext {
             }
             result.initialFiles.forEach((value, key) => initialFiles.set(key, value));
             outputFiles.push(...result.outputFiles);
-            result.externalImports.forEach((value) => externalImports.add(value));
+            result.externalImports.browser?.forEach((value) => externalImportsBrowser.add(value));
+            result.externalImports.server?.forEach((value) => externalImportsServer.add(value));
         }
         if (errors !== undefined) {
             return { errors, warnings };
@@ -95,7 +97,10 @@ class BundlerContext {
             metafile,
             initialFiles,
             outputFiles,
-            externalImports,
+            externalImports: {
+                browser: externalImportsBrowser,
+                server: externalImportsServer,
+            },
         };
     }
     /**
@@ -241,16 +246,14 @@ class BundlerContext {
                 externalImports.add(importData.path);
             }
         }
+        const platformIsServer = this.#esbuildOptions?.platform === 'node';
         const outputFiles = result.outputFiles.map((file) => {
             let fileType;
             if ((0, node_path_1.dirname)(file.path) === 'media') {
                 fileType = BuildOutputFileType.Media;
             }
             else {
-                fileType =
-                    this.#esbuildOptions?.platform === 'node'
-                        ? BuildOutputFileType.Server
-                        : BuildOutputFileType.Browser;
+                fileType = platformIsServer ? BuildOutputFileType.Server : BuildOutputFileType.Browser;
             }
             return (0, utils_1.convertOutputFile)(file, fileType);
         });
@@ -259,7 +262,9 @@ class BundlerContext {
             ...result,
             outputFiles,
             initialFiles,
-            externalImports,
+            externalImports: {
+                [platformIsServer ? 'server' : 'browser']: externalImports,
+            },
             errors: undefined,
         };
     }

package/src/tools/esbuild/bundler-execution-result.d.ts

@@ -5,7 +5,7 @@
  * 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 { Message } from 'esbuild';
+import type { Message, PartialMessage } from 'esbuild';
 import type { ChangedFiles } from '../../tools/esbuild/watcher';
 import type { SourceFileCache } from './angular/source-file-cache';
 import type { BuildOutputFile, BuildOutputFileType, BundlerContext } from './bundler-context';
@@ -17,6 +17,12 @@ export interface RebuildState {
     rebuildContexts: BundlerContext[];
     codeBundleCache?: SourceFileCache;
     fileChanges: ChangedFiles;
+    previousOutputHashes: Map<string, string>;
+}
+export interface ExternalResultMetadata {
+    implicitBrowser: string[];
+    implicitServer: string[];
+    explicit: string[];
 }
 /**
  * Represents the result of a single builder execute call.
@@ -26,22 +32,20 @@ export declare class ExecutionResult {
     private codeBundleCache?;
     outputFiles: BuildOutputFile[];
     assetFiles: BuildOutputAsset[];
-    errors: Message[];
-    externalMetadata?: {
-        implicit: string[];
-        explicit?: string[];
-    };
+    errors: (Message | PartialMessage)[];
+    externalMetadata?: ExternalResultMetadata;
     constructor(rebuildContexts: BundlerContext[], codeBundleCache?: SourceFileCache | undefined);
     addOutputFile(path: string, content: string, type: BuildOutputFileType): void;
     addAssets(assets: BuildOutputAsset[]): void;
-    addErrors(errors: Message[]): void;
+    addErrors(errors: (Message | PartialMessage)[]): void;
     /**
      * Add external JavaScript import metadata to the result. This is currently used
      * by the development server to optimize the prebundling process.
-     * @param implicit External dependencies due to the external packages option.
+     * @param implicitBrowser External dependencies for the browser bundles due to the external packages option.
+     * @param implicitServer External dependencies for the server bundles due to the external packages option.
      * @param explicit External dependencies due to explicit project configuration.
      */
-    setExternalMetadata(implicit: string[], explicit: string[] | undefined): void;
+    setExternalMetadata(implicitBrowser: string[], implicitServer: string[], explicit: string[] | undefined): void;
     get output(): {
         success: boolean;
     };
@@ -49,13 +53,11 @@ export declare class ExecutionResult {
         success: boolean;
         outputFiles: BuildOutputFile[];
         assetFiles: BuildOutputAsset[];
-        errors: Message[];
-        externalMetadata: {
-            implicit: string[];
-            explicit?: string[] | undefined;
-        } | undefined;
+        errors: (PartialMessage | Message)[];
+        externalMetadata: ExternalResultMetadata | undefined;
     };
     get watchFiles(): string[];
     createRebuildState(fileChanges: ChangedFiles): RebuildState;
+    findChangedFiles(previousOutputHashes: Map<string, string>): Set<string>;
     dispose(): Promise<void>;
 }

package/src/tools/esbuild/bundler-execution-result.js

@@ -35,11 +35,12 @@ class ExecutionResult {
     /**
      * Add external JavaScript import metadata to the result. This is currently used
      * by the development server to optimize the prebundling process.
-     * @param implicit External dependencies due to the external packages option.
+     * @param implicitBrowser External dependencies for the browser bundles due to the external packages option.
+     * @param implicitServer External dependencies for the server bundles due to the external packages option.
      * @param explicit External dependencies due to explicit project configuration.
      */
-    setExternalMetadata(implicit, explicit) {
-        this.externalMetadata = { implicit, explicit };
+    setExternalMetadata(implicitBrowser, implicitServer, explicit) {
+        this.externalMetadata = { implicitBrowser, implicitServer, explicit: explicit ?? [] };
     }
     get output() {
         return {
@@ -60,6 +61,9 @@ class ExecutionResult {
         if (this.codeBundleCache?.referencedFiles) {
             files.push(...this.codeBundleCache.referencedFiles);
         }
+        if (this.codeBundleCache?.loadResultCache) {
+            files.push(...this.codeBundleCache.loadResultCache.watchFiles);
+        }
         return files;
     }
     createRebuildState(fileChanges) {
@@ -68,8 +72,19 @@ class ExecutionResult {
             rebuildContexts: this.rebuildContexts,
             codeBundleCache: this.codeBundleCache,
             fileChanges,
+            previousOutputHashes: new Map(this.outputFiles.map((file) => [file.path, file.hash])),
         };
     }
+    findChangedFiles(previousOutputHashes) {
+        const changed = new Set();
+        for (const file of this.outputFiles) {
+            const previousHash = previousOutputHashes.get(file.path);
+            if (previousHash === undefined || previousHash !== file.hash) {
+                changed.add(file.path);
+            }
+        }
+        return changed;
+    }
     async dispose() {
         await Promise.allSettled(this.rebuildContexts.map((context) => context.dispose()));
     }

package/src/tools/esbuild/commonjs-checker.js

@@ -38,6 +38,10 @@ function checkCommonJSModules(metafile, allowedCommonJsDependencies) {
     // Used by '@angular/platform-server' and is in a seperate chunk that is unused when
     // using `provideHttpClient(withFetch())`.
     allowedRequests.add('xhr2');
+    // Packages used by @angular/ssr.
+    // While critters is ESM it has a number of direct and transtive CJS deps.
+    allowedRequests.add('express');
+    allowedRequests.add('critters');
     // Find all entry points that contain code (JS/TS)
     const files = [];
     for (const { entryPoint } of Object.values(metafile.outputs)) {
@@ -62,6 +66,10 @@ function checkCommonJSModules(metafile, allowedCommonJsDependencies) {
                 continue;
             }
             seenFiles.add(imported.path);
+            // If the dependency is allowed ignore all other checks
+            if (allowedRequests.has(imported.original)) {
+                continue;
+            }
             // Only check actual code files
             if (!isPathCode(imported.path)) {
                 continue;
@@ -84,11 +92,11 @@ function checkCommonJSModules(metafile, allowedCommonJsDependencies) {
                     }
                 }
                 if (notAllowed) {
-                    // Issue a diagnostic message and skip all descendants since they are also most
-                    // likely not ESM but solved by addressing this import.
+                    // Issue a diagnostic message for CommonJS module
                     messages.push(createCommonJSModuleError(request, currentFile));
-                    continue;
                 }
+                // Skip all descendants since they are also most likely not ESM but solved by addressing this import
+                continue;
             }
             // Add the path so that its imports can be checked
             files.push(imported.path);
@@ -117,10 +125,7 @@ function isPathCode(name) {
  * @returns True, if specifier is potentially relative; false, otherwise.
  */
 function isPotentialRelative(specifier) {
-    if (specifier[0] === '.') {
-        return true;
-    }
-    return false;
+    return specifier[0] === '.';
 }
 /**
  * Creates an esbuild diagnostic message for a given non-ESM module request.

package/src/tools/esbuild/global-scripts.d.ts

@@ -13,4 +13,4 @@ import { BundlerOptionsFactory } from './bundler-context';
  * @param options The builder's user-provider normalized options.
  * @returns An esbuild BuildOptions object.
  */
-export declare function createGlobalScriptsBundleOptions(options: NormalizedApplicationBuildOptions, initial: boolean): BundlerOptionsFactory | undefined;
+export declare function createGlobalScriptsBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], initial: boolean): BundlerOptionsFactory | undefined;

package/src/tools/esbuild/global-scripts.js

@@ -48,7 +48,7 @@ const virtual_module_plugin_1 = require("./virtual-module-plugin");
  * @param options The builder's user-provider normalized options.
  * @returns An esbuild BuildOptions object.
  */
-function createGlobalScriptsBundleOptions(options, initial) {
+function createGlobalScriptsBundleOptions(options, target, initial) {
     const { globalScripts, optimizationOptions, outputNames, preserveSymlinks, sourcemapOptions, workspaceRoot, } = options;
     const namespace = 'angular:script/global';
     const entryPoints = {};
@@ -81,6 +81,7 @@ function createGlobalScriptsBundleOptions(options, initial) {
             sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
             write: false,
             platform: 'neutral',
+            target,
             preserveSymlinks,
             plugins: [
                 (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),

package/src/tools/esbuild/javascript-transformer.d.ts

@@ -23,7 +23,8 @@ export interface JavaScriptTransformerOptions {
  */
 export declare class JavaScriptTransformer {
     #private;
-    constructor(options: JavaScriptTransformerOptions, maxThreads: number);
+    readonly maxThreads: number;
+    constructor(options: JavaScriptTransformerOptions, maxThreads: number, reuseResults?: boolean);
     /**
      * Performs JavaScript transformations on a file from the filesystem.
      * If no transformations are required, the data for the original file will be returned.