@angular-devkit/build-angular 15.0.0-next.3 → 15.0.0-next.5

package/src/builders/browser-esbuild/compiler-plugin.js

@@ -33,21 +33,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCompilerPlugin = void 0;
+exports.createCompilerPlugin = exports.SourceFileCache = void 0;
 const core_1 = require("@babel/core");
 const assert = __importStar(require("assert"));
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path = __importStar(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const application_1 = __importDefault(require("../../babel/presets/application"));
 const webpack_loader_1 = require("../../babel/webpack-loader");
 const load_esm_1 = require("../../utils/load-esm");
+const profiling_1 = require("./profiling");
 const stylesheets_1 = require("./stylesheets");
 /**
  * Converts TypeScript Diagnostic related information into an esbuild compatible note object.
  * Related information is a subset of a full TypeScript Diagnostic and also used for diagnostic
  * notes associated with the main Diagnostic.
- * @param diagnostic The TypeScript diagnostic relative information to convert.
+ * @param info The TypeScript diagnostic relative information to convert.
  * @param host A TypeScript FormatDiagnosticsHost instance to use during conversion.
  * @returns An esbuild diagnostic message as a PartialMessage object
  */
@@ -106,6 +108,28 @@ function convertTypeScriptDiagnostic(diagnostic, host) {
     }
     return message;
 }
+const USING_WINDOWS = (0, os_1.platform)() === 'win32';
+const WINDOWS_SEP_REGEXP = new RegExp(`\\${path.win32.sep}`, 'g');
+class SourceFileCache extends Map {
+    constructor() {
+        super(...arguments);
+        this.modifiedFiles = new Set();
+        this.babelFileCache = new Map();
+    }
+    invalidate(files) {
+        this.modifiedFiles.clear();
+        for (let file of files) {
+            this.babelFileCache.delete(file);
+            // Normalize separators to allow matching TypeScript Host paths
+            if (USING_WINDOWS) {
+                file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);
+            }
+            this.delete(file);
+            this.modifiedFiles.add(file);
+        }
+    }
+}
+exports.SourceFileCache = SourceFileCache;
 // This is a non-watch version of the compiler code from `@ngtools/webpack` augmented for esbuild
 // eslint-disable-next-line max-lines-per-function
 function createCompilerPlugin(pluginOptions, styleOptions) {
@@ -115,14 +139,15 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
         async setup(build) {
             var _a, _b;
             var _c;
+            let setupWarnings;
             // This uses a wrapped dynamic import to load `@angular/compiler-cli` which is ESM.
             // Once TypeScript provides support for retaining dynamic imports this workaround can be dropped.
-            const compilerCli = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli');
+            const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT, NgtscProgram, OptimizeFor, readConfiguration } = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli');
             // Temporary deep import for transformer support
             const { mergeTransformers, replaceBootstrap, } = require('@ngtools/webpack/src/ivy/transformation');
             // Setup defines based on the values provided by the Angular compiler-cli
             (_a = (_c = build.initialOptions).define) !== null && _a !== void 0 ? _a : (_c.define = {});
-            for (const [key, value] of Object.entries(compilerCli.GLOBAL_DEFS_FOR_TERSER_WITH_AOT)) {
+            for (const [key, value] of Object.entries(GLOBAL_DEFS_FOR_TERSER_WITH_AOT)) {
                 if (key in build.initialOptions.define) {
                     // Skip keys that have been manually provided
                     continue;
@@ -133,7 +158,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
             }
             // The tsconfig is loaded in setup instead of in start to allow the esbuild target build option to be modified.
             // esbuild build options can only be modified in setup prior to starting the build.
-            const { options: compilerOptions, rootNames, errors: configurationDiagnostics, } = compilerCli.readConfiguration(pluginOptions.tsconfig, {
+            const { options: compilerOptions, rootNames, errors: configurationDiagnostics, } = (0, profiling_1.profileSync)('NG_READ_CONFIG', () => readConfiguration(pluginOptions.tsconfig, {
                 noEmitOnError: false,
                 suppressOutputPathCheck: true,
                 outDir: undefined,
@@ -147,22 +172,41 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                 allowEmptyCodegenFiles: false,
                 annotationsAs: 'decorators',
                 enableResourceInlining: false,
-            });
+            }));
             if (compilerOptions.target === undefined || compilerOptions.target < typescript_1.default.ScriptTarget.ES2022) {
                 // 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 = typescript_1.default.ScriptTarget.ES2022;
                 (_b = compilerOptions.useDefineForClassFields) !== null && _b !== void 0 ? _b : (compilerOptions.useDefineForClassFields = false);
-                // TODO: show warning about this override when we have access to the logger.
+                (setupWarnings !== null && setupWarnings !== void 0 ? setupWarnings : (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://github.com/browserslist/browserslist#queries'`,
+                        },
+                    ],
+                });
             }
             // The file emitter created during `onStart` that will be used during the build in `onLoad` callbacks for TS files
             let fileEmitter;
             // The stylesheet resources from component stylesheets that will be added to the build results output files
             let stylesheetResourceFiles;
+            let previousBuilder;
+            let previousAngularProgram;
+            const babelDataCache = new Map();
+            const diagnosticCache = new WeakMap();
             build.onStart(async () => {
-                var _a, _b;
-                const result = {};
+                const result = {
+                    warnings: setupWarnings,
+                };
+                // Reset the setup warnings so that they are only shown during the first build.
+                setupWarnings = undefined;
+                // Reset debug performance tracking
+                (0, profiling_1.resetCumulativeDurations)();
                 // Reset stylesheet resource output files
                 stylesheetResourceFiles = [];
                 // Create TypeScript compiler host
@@ -201,53 +245,81 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     stylesheetResourceFiles.push(...resourceFiles);
                     return { content: contents };
                 };
+                // Temporary deep import for host augmentation support
+                const { augmentHostWithCaching, augmentHostWithReplacements, augmentProgramWithVersioning, } = require('@ngtools/webpack/src/ivy/host');
                 // Augment TypeScript Host for file replacements option
                 if (pluginOptions.fileReplacements) {
-                    // Temporary deep import for file replacements support
-                    const { augmentHostWithReplacements } = require('@ngtools/webpack/src/ivy/host');
                     augmentHostWithReplacements(host, pluginOptions.fileReplacements);
                 }
+                // Augment TypeScript Host with source file caching if provided
+                if (pluginOptions.sourceFileCache) {
+                    augmentHostWithCaching(host, pluginOptions.sourceFileCache);
+                    // Allow the AOT compiler to request the set of changed templates and styles
+                    host.getModifiedResourceFiles = function () {
+                        var _a;
+                        return (_a = pluginOptions.sourceFileCache) === null || _a === void 0 ? void 0 : _a.modifiedFiles;
+                    };
+                }
                 // Create the Angular specific program that contains the Angular compiler
-                const angularProgram = new compilerCli.NgtscProgram(rootNames, compilerOptions, host);
+                const angularProgram = (0, profiling_1.profileSync)('NG_CREATE_PROGRAM', () => new NgtscProgram(rootNames, compilerOptions, host, previousAngularProgram));
+                previousAngularProgram = angularProgram;
                 const angularCompiler = angularProgram.compiler;
-                const { ignoreForDiagnostics } = angularCompiler;
                 const typeScriptProgram = angularProgram.getTsProgram();
-                const builder = typescript_1.default.createAbstractBuilder(typeScriptProgram, host);
-                await angularCompiler.analyzeAsync();
+                augmentProgramWithVersioning(typeScriptProgram);
+                const builder = typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, host, previousBuilder, configurationDiagnostics);
+                previousBuilder = builder;
+                await (0, profiling_1.profileAsync)('NG_ANALYZE_PROGRAM', () => angularCompiler.analyzeAsync());
                 function* collectDiagnostics() {
                     // Collect program level diagnostics
-                    yield* configurationDiagnostics;
+                    yield* builder.getConfigFileParsingDiagnostics();
                     yield* angularCompiler.getOptionDiagnostics();
                     yield* builder.getOptionsDiagnostics();
                     yield* builder.getGlobalDiagnostics();
                     // Collect source file specific diagnostics
-                    const OptimizeFor = compilerCli.OptimizeFor;
+                    const affectedFiles = findAffectedFiles(builder, angularCompiler);
+                    const optimizeFor = affectedFiles.size > 1 ? OptimizeFor.WholeProgram : OptimizeFor.SingleFile;
                     for (const sourceFile of builder.getSourceFiles()) {
-                        if (ignoreForDiagnostics.has(sourceFile)) {
+                        if (angularCompiler.ignoreForDiagnostics.has(sourceFile)) {
                             continue;
                         }
-                        yield* builder.getSyntacticDiagnostics(sourceFile);
-                        yield* builder.getSemanticDiagnostics(sourceFile);
-                        const angularDiagnostics = angularCompiler.getDiagnosticsForFile(sourceFile, OptimizeFor.WholeProgram);
-                        yield* angularDiagnostics;
+                        // TypeScript will use cached diagnostics for files that have not been
+                        // changed or affected for this build when using incremental building.
+                        yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SYNTACTIC', () => builder.getSyntacticDiagnostics(sourceFile), true);
+                        yield* (0, profiling_1.profileSync)('NG_DIAGNOSTICS_SEMANTIC', () => builder.getSemanticDiagnostics(sourceFile), true);
+                        // Only request Angular template diagnostics for affected files to avoid
+                        // overhead of template diagnostics for unchanged files.
+                        if (affectedFiles.has(sourceFile)) {
+                            const angularDiagnostics = (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TEMPLATE', () => angularCompiler.getDiagnosticsForFile(sourceFile, optimizeFor), true);
+                            diagnosticCache.set(sourceFile, angularDiagnostics);
+                            yield* angularDiagnostics;
+                        }
+                        else {
+                            const angularDiagnostics = diagnosticCache.get(sourceFile);
+                            if (angularDiagnostics) {
+                                yield* angularDiagnostics;
+                            }
+                        }
                     }
                 }
-                for (const diagnostic of collectDiagnostics()) {
-                    const message = convertTypeScriptDiagnostic(diagnostic, host);
-                    if (diagnostic.category === typescript_1.default.DiagnosticCategory.Error) {
-                        ((_a = result.errors) !== null && _a !== void 0 ? _a : (result.errors = [])).push(message);
-                    }
-                    else {
-                        ((_b = result.warnings) !== null && _b !== void 0 ? _b : (result.warnings = [])).push(message);
+                (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TOTAL', () => {
+                    var _a, _b;
+                    for (const diagnostic of collectDiagnostics()) {
+                        const message = convertTypeScriptDiagnostic(diagnostic, host);
+                        if (diagnostic.category === typescript_1.default.DiagnosticCategory.Error) {
+                            ((_a = result.errors) !== null && _a !== void 0 ? _a : (result.errors = [])).push(message);
+                        }
+                        else {
+                            ((_b = result.warnings) !== null && _b !== void 0 ? _b : (result.warnings = [])).push(message);
+                        }
                     }
-                }
+                });
                 fileEmitter = createFileEmitter(builder, mergeTransformers(angularCompiler.prepareEmit().transformers, {
                     before: [replaceBootstrap(() => builder.getProgram().getTypeChecker())],
-                }), () => []);
+                }), (sourceFile) => angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile));
                 return result;
             });
-            build.onLoad({ filter: compilerOptions.allowJs ? /\.[cm]?[jt]sx?$/ : /\.[cm]?tsx?$/ }, async (args) => {
-                var _a, _b, _c, _d;
+            build.onLoad({ filter: compilerOptions.allowJs ? /\.[cm]?[jt]sx?$/ : /\.[cm]?tsx?$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_TS*', async () => {
+                var _a, _b, _c;
                 assert.ok(fileEmitter, 'Invalid plugin execution order');
                 const typescriptResult = await fileEmitter((_b = (_a = pluginOptions.fileReplacements) === null || _a === void 0 ? void 0 : _a[args.path]) !== null && _b !== void 0 ? _b : args.path);
                 if (!typescriptResult) {
@@ -260,8 +332,7 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     return {
                         errors: [
                             {
-                                text: 'File is missing from the TypeScript compilation.',
-                                location: { file: args.path },
+                                text: `File '${args.path}' is missing from the TypeScript compilation.`,
                                 notes: [
                                     {
                                         text: `Ensure the file is part of the TypeScript program via the 'files' or 'include' property.`,
@@ -272,99 +343,43 @@ function createCompilerPlugin(pluginOptions, styleOptions) {
                     };
                 }
                 const data = (_c = typescriptResult.content) !== null && _c !== void 0 ? _c : '';
-                const forceAsyncTransformation = /async\s+function\s*\*/.test(data);
-                const useInputSourcemap = pluginOptions.sourcemap &&
-                    (!!pluginOptions.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(args.path));
-                // If no additional transformations are needed, return the TypeScript output directly
-                if (!forceAsyncTransformation && !pluginOptions.advancedOptimizations) {
-                    return {
-                        // Strip sourcemaps if they should not be used
-                        contents: useInputSourcemap
-                            ? data
-                            : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''),
-                        loader: 'js',
-                    };
+                // The pre-transformed data is used as a cache key. Since the cache is memory only,
+                // the options cannot change and do not need to be represented in the key. If the
+                // cache is later stored to disk, then the options that affect transform output
+                // would need to be added to the key as well.
+                let contents = babelDataCache.get(data);
+                if (contents === undefined) {
+                    contents = await transformWithBabel(args.path, data, pluginOptions);
+                    babelDataCache.set(data, contents);
                 }
-                const babelResult = await (0, core_1.transformAsync)(data, {
-                    filename: args.path,
-                    inputSourceMap: (useInputSourcemap ? undefined : false),
-                    sourceMaps: pluginOptions.sourcemap ? 'inline' : false,
-                    compact: false,
-                    configFile: false,
-                    babelrc: false,
-                    browserslistConfigFile: false,
-                    plugins: [],
-                    presets: [
-                        [
-                            application_1.default,
-                            {
-                                forceAsyncTransformation,
-                                optimize: pluginOptions.advancedOptimizations && {},
-                            },
-                        ],
-                    ],
-                });
                 return {
-                    contents: (_d = babelResult === null || babelResult === void 0 ? void 0 : babelResult.code) !== null && _d !== void 0 ? _d : '',
+                    contents,
                     loader: 'js',
                 };
-            });
-            build.onLoad({ filter: /\.[cm]?js$/ }, async (args) => {
-                var _a;
-                const data = await fs_1.promises.readFile(args.path, 'utf-8');
-                const forceAsyncTransformation = !/[\\/][_f]?esm2015[\\/]/.test(args.path) && /async\s+function\s*\*/.test(data);
-                const shouldLink = await (0, webpack_loader_1.requiresLinking)(args.path, data);
-                const useInputSourcemap = pluginOptions.sourcemap &&
-                    (!!pluginOptions.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(args.path));
-                // If no additional transformations are needed, return the TypeScript output directly
-                if (!forceAsyncTransformation && !pluginOptions.advancedOptimizations && !shouldLink) {
-                    return {
-                        // Strip sourcemaps if they should not be used
-                        contents: useInputSourcemap
-                            ? data
-                            : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''),
-                        loader: 'js',
-                    };
+            }, true));
+            build.onLoad({ filter: /\.[cm]?js$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_JS*', async () => {
+                var _a, _b;
+                // The filename is currently used as a cache key. Since the cache is memory only,
+                // the options cannot change and do not need to be represented in the key. If the
+                // cache is later stored to disk, then the options that affect transform output
+                // would need to be added to the key as well as a check for any change of content.
+                let contents = (_a = pluginOptions.sourceFileCache) === null || _a === void 0 ? void 0 : _a.babelFileCache.get(args.path);
+                if (contents === undefined) {
+                    const data = await fs_1.promises.readFile(args.path, 'utf-8');
+                    contents = await transformWithBabel(args.path, data, pluginOptions);
+                    (_b = pluginOptions.sourceFileCache) === null || _b === void 0 ? void 0 : _b.babelFileCache.set(args.path, contents);
                 }
-                const angularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(args.path);
-                const linkerPluginCreator = (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin;
-                const result = await (0, core_1.transformAsync)(data, {
-                    filename: args.path,
-                    inputSourceMap: (useInputSourcemap ? undefined : false),
-                    sourceMaps: pluginOptions.sourcemap ? 'inline' : false,
-                    compact: false,
-                    configFile: false,
-                    babelrc: false,
-                    browserslistConfigFile: false,
-                    plugins: [],
-                    presets: [
-                        [
-                            application_1.default,
-                            {
-                                angularLinker: {
-                                    shouldLink,
-                                    jitMode: false,
-                                    linkerPluginCreator,
-                                },
-                                forceAsyncTransformation,
-                                optimize: pluginOptions.advancedOptimizations && {
-                                    looseEnums: angularPackage,
-                                    pureTopLevel: angularPackage,
-                                },
-                            },
-                        ],
-                    ],
-                });
                 return {
-                    contents: (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : data,
+                    contents,
                     loader: 'js',
                 };
-            });
+            }, true));
             build.onEnd((result) => {
                 var _a;
                 if (stylesheetResourceFiles.length) {
                     (_a = result.outputFiles) === null || _a === void 0 ? void 0 : _a.push(...stylesheetResourceFiles);
                 }
+                (0, profiling_1.logCumulativeDurations)();
             });
         },
     };
@@ -386,3 +401,84 @@ function createFileEmitter(program, transformers = {}, onAfterEmit) {
         return { content, dependencies: [] };
     };
 }
+async function transformWithBabel(filename, data, pluginOptions) {
+    var _a;
+    const forceAsyncTransformation = !/[\\/][_f]?esm2015[\\/]/.test(filename) && /async\s+function\s*\*/.test(data);
+    const shouldLink = await (0, webpack_loader_1.requiresLinking)(filename, data);
+    const useInputSourcemap = pluginOptions.sourcemap &&
+        (!!pluginOptions.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
+    // If no additional transformations are needed, return the data directly
+    if (!forceAsyncTransformation && !pluginOptions.advancedOptimizations && !shouldLink) {
+        // Strip sourcemaps if they should not be used
+        return useInputSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, '');
+    }
+    const angularPackage = /[\\/]node_modules[\\/]@angular[\\/]/.test(filename);
+    const linkerPluginCreator = shouldLink
+        ? (await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli/linker/babel')).createEs2015LinkerPlugin
+        : undefined;
+    const result = await (0, core_1.transformAsync)(data, {
+        filename,
+        inputSourceMap: (useInputSourcemap ? undefined : false),
+        sourceMaps: pluginOptions.sourcemap ? 'inline' : false,
+        compact: false,
+        configFile: false,
+        babelrc: false,
+        browserslistConfigFile: false,
+        plugins: [],
+        presets: [
+            [
+                application_1.default,
+                {
+                    angularLinker: {
+                        shouldLink,
+                        jitMode: false,
+                        linkerPluginCreator,
+                    },
+                    forceAsyncTransformation,
+                    optimize: pluginOptions.advancedOptimizations && {
+                        looseEnums: angularPackage,
+                        pureTopLevel: angularPackage,
+                    },
+                },
+            ],
+        ],
+    });
+    return (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : data;
+}
+function findAffectedFiles(builder, { ignoreForDiagnostics, ignoreForEmit, incrementalCompilation }) {
+    const affectedFiles = new Set();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+            // If the affected file is a TTC shim, add the shim's original source file.
+            // This ensures that changes that affect TTC are typechecked even when the changes
+            // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
+            // For example, changing @Input property types of a directive used in another component's
+            // template.
+            // A TTC shim is a file that has been ignored for diagnostics and has a filename ending in `.ngtypecheck.ts`.
+            if (ignoreForDiagnostics.has(sourceFile) && sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                // This file name conversion relies on internal compiler logic and should be converted
+                // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                const originalSourceFile = builder.getSourceFile(originalFilename);
+                if (originalSourceFile) {
+                    affectedFiles.add(originalSourceFile);
+                }
+                return true;
+            }
+            return false;
+        });
+        if (!result) {
+            break;
+        }
+        affectedFiles.add(result.affected);
+    }
+    // A file is also affected if the Angular compiler requires it to be emitted
+    for (const sourceFile of builder.getSourceFiles()) {
+        if (ignoreForEmit.has(sourceFile) || incrementalCompilation.safeToSkipEmit(sourceFile)) {
+            continue;
+        }
+        affectedFiles.add(sourceFile);
+    }
+    return affectedFiles;
+}

package/src/builders/browser-esbuild/esbuild.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BuilderContext } from '@angular-devkit/architect';
-import { BuildFailure, BuildOptions, BuildResult, Message, OutputFile } from 'esbuild';
+import { BuildFailure, BuildInvalidate, BuildOptions, BuildResult, Message, OutputFile } from 'esbuild';
 /**
  * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild.
  * @param value A potential esbuild BuildFailure error object.
@@ -19,11 +19,12 @@ export declare function isEsBuildFailure(value: unknown): value is BuildFailure;
  * All builds use the `write` option with a value of `false` to allow for the output files
  * build result array to be populated.
  *
- * @param options The esbuild options object to use when building.
+ * @param optionsOrInvalidate The esbuild options object to use when building or the invalidate object
+ * returned from an incremental build to perform an additional incremental build.
  * @returns If output files are generated, the full esbuild BuildResult; if not, the
  * warnings and errors for the attempted build.
  */
-export declare function bundle(options: BuildOptions): Promise<(BuildResult & {
+export declare function bundle(optionsOrInvalidate: BuildOptions | BuildInvalidate): Promise<(BuildResult & {
     outputFiles: OutputFile[];
 }) | (BuildFailure & {
     outputFiles?: never;

package/src/builders/browser-esbuild/esbuild.js

@@ -24,16 +24,22 @@ exports.isEsBuildFailure = isEsBuildFailure;
  * All builds use the `write` option with a value of `false` to allow for the output files
  * build result array to be populated.
  *
- * @param options The esbuild options object to use when building.
+ * @param optionsOrInvalidate The esbuild options object to use when building or the invalidate object
+ * returned from an incremental build to perform an additional incremental build.
  * @returns If output files are generated, the full esbuild BuildResult; if not, the
  * warnings and errors for the attempted build.
  */
-async function bundle(options) {
+async function bundle(optionsOrInvalidate) {
     try {
-        return await (0, esbuild_1.build)({
-            ...options,
-            write: false,
-        });
+        if (typeof optionsOrInvalidate === 'function') {
+            return (await optionsOrInvalidate());
+        }
+        else {
+            return await (0, esbuild_1.build)({
+                ...optionsOrInvalidate,
+                write: false,
+            });
+        }
     }
     catch (failure) {
         // Build failures will throw an exception which contains errors/warnings

package/src/builders/browser-esbuild/experimental-warnings.js

@@ -24,9 +24,6 @@ const UNSUPPORTED_OPTIONS = [
     'inlineStyleLanguage',
     // The following option has no effect until preprocessors are supported
     // 'stylePreprocessorOptions',
-    // * Watch mode
-    'watch',
-    'poll',
     // * Deprecated
     'deployUrl',
     // * Always enabled with esbuild

package/src/builders/browser-esbuild/index.d.ts

@@ -10,10 +10,10 @@ import { Schema as BrowserBuilderOptions } from './schema';
 /**
  * Main execution function for the esbuild-based application builder.
  * The options are compatible with the Webpack-based builder.
- * @param options The browser builder options to use when setting up the application build
+ * @param initialOptions The browser builder options to use when setting up the application build
  * @param context The Architect builder context object
- * @returns A promise with the builder result output
+ * @returns An async iterable with the builder result output
  */
-export declare function buildEsbuildBrowser(options: BrowserBuilderOptions, context: BuilderContext): Promise<BuilderOutput>;
+export declare function buildEsbuildBrowser(initialOptions: BrowserBuilderOptions, context: BuilderContext): AsyncIterable<BuilderOutput>;
 declare const _default: import("@angular-devkit/architect/src/internal").Builder<BrowserBuilderOptions & import("../../../../core/src").JsonObject>;
 export default _default;