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

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

@@ -33,67 +33,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildEsbuildBrowser = void 0;
 const architect_1 = require("@angular-devkit/architect");
 const assert = __importStar(require("assert"));
-const fs_1 = require("fs");
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const utils_1 = require("../../utils");
 const copy_assets_1 = require("../../utils/copy-assets");
 const error_1 = require("../../utils/error");
 const esbuild_targets_1 = require("../../utils/esbuild-targets");
 const index_html_generator_1 = require("../../utils/index-file/index-html-generator");
-const package_chunk_sort_1 = require("../../utils/package-chunk-sort");
 const service_worker_1 = require("../../utils/service-worker");
 const supported_browsers_1 = require("../../utils/supported-browsers");
-const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
-const configs_1 = require("../../webpack/configs");
 const compiler_plugin_1 = require("./compiler-plugin");
 const esbuild_1 = require("./esbuild");
 const experimental_warnings_1 = require("./experimental-warnings");
 const options_1 = require("./options");
 const stylesheets_1 = require("./stylesheets");
+const watcher_1 = require("./watcher");
 /**
- * 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 context The Architect builder context object
- * @returns A promise with the builder result output
+ * Represents the result of a single builder execute call.
  */
-// eslint-disable-next-line max-lines-per-function
-async function buildEsbuildBrowser(options, context) {
-    var _a, _b, _c, _d, _e, _f;
-    const startTime = Date.now();
-    // Only AOT is currently supported
-    if (options.aot !== true) {
-        context.logger.error('JIT mode is currently not supported by this experimental builder. AOT mode must be used.');
-        return { success: false };
-    }
-    // Inform user of experimental status of builder and options
-    (0, experimental_warnings_1.logExperimentalWarnings)(options, context);
-    // Determine project name from builder context target
-    const projectName = (_a = context.target) === null || _a === void 0 ? void 0 : _a.project;
-    if (!projectName) {
-        context.logger.error(`The 'browser-esbuild' builder requires a target to be specified.`);
-        return { success: false };
+class ExecutionResult {
+    constructor(success, codeRebuild, codeBundleCache) {
+        this.success = success;
+        this.codeRebuild = codeRebuild;
+        this.codeBundleCache = codeBundleCache;
     }
-    const { projectRoot, workspaceRoot, entryPoints, entryPointNameLookup, optimizationOptions, outputPath, sourcemapOptions, tsconfig, assets, outputNames, } = await (0, options_1.normalizeOptions)(context, projectName, options);
-    // Clean output path if enabled
-    if (options.deleteOutputPath) {
-        (0, utils_1.deleteOutputDir)(workspaceRoot, options.outputPath);
+    get output() {
+        return {
+            success: this.success,
+        };
     }
-    // Create output directory if needed
-    try {
-        await fs_1.promises.mkdir(outputPath, { recursive: true });
+    createRebuildState(fileChanges) {
+        var _a;
+        (_a = this.codeBundleCache) === null || _a === void 0 ? void 0 : _a.invalidate([...fileChanges.modified, ...fileChanges.removed]);
+        return {
+            codeRebuild: this.codeRebuild,
+            codeBundleCache: this.codeBundleCache,
+            fileChanges,
+        };
     }
-    catch (e) {
-        (0, error_1.assertIsError)(e);
-        context.logger.error('Unable to create output directory: ' + e.message);
-        return { success: false };
+    dispose() {
+        var _a;
+        (_a = this.codeRebuild) === null || _a === void 0 ? void 0 : _a.dispose();
     }
+}
+async function execute(options, context, rebuildState) {
+    var _a, _b, _c, _d;
+    const startTime = Date.now();
+    const { projectRoot, workspaceRoot, optimizationOptions, outputPath, assets, serviceWorkerOptions, indexHtmlOptions, } = options;
     const target = (0, esbuild_targets_1.transformSupportedBrowsersToTargets)((0, supported_browsers_1.getSupportedBrowsers)(projectRoot, context.logger));
+    const codeBundleCache = options.watch
+        ? (_a = rebuildState === null || rebuildState === void 0 ? void 0 : rebuildState.codeBundleCache) !== null && _a !== void 0 ? _a : new compiler_plugin_1.SourceFileCache()
+        : undefined;
     const [codeResults, styleResults] = await Promise.all([
         // Execute esbuild to bundle the application code
-        bundleCode(workspaceRoot, entryPoints, outputNames, options, optimizationOptions, sourcemapOptions, tsconfig, target),
+        (0, esbuild_1.bundle)((_b = rebuildState === null || rebuildState === void 0 ? void 0 : rebuildState.codeRebuild) !== null && _b !== void 0 ? _b : createCodeBundleOptions(options, target, codeBundleCache)),
         // Execute esbuild to bundle the global stylesheets
-        bundleGlobalStylesheets(workspaceRoot, outputNames, options, optimizationOptions, sourcemapOptions, target),
+        bundleGlobalStylesheets(options, target),
     ]);
     // Log all warnings and errors generated during bundling
     await (0, esbuild_1.logMessages)(context, {
@@ -102,7 +97,7 @@ async function buildEsbuildBrowser(options, context) {
     });
     // Return if the bundling failed to generate output files or there are errors
     if (!codeResults.outputFiles || codeResults.errors.length) {
-        return { success: false };
+        return new ExecutionResult(false, rebuildState === null || rebuildState === void 0 ? void 0 : rebuildState.codeRebuild, codeBundleCache);
     }
     // Structure the code bundling output files
     const initialFiles = [];
@@ -110,13 +105,14 @@ async function buildEsbuildBrowser(options, context) {
     for (const outputFile of codeResults.outputFiles) {
         // Entries in the metafile are relative to the `absWorkingDir` option which is set to the workspaceRoot
         const relativeFilePath = path.relative(workspaceRoot, outputFile.path);
-        const entryPoint = (_c = (_b = codeResults.metafile) === null || _b === void 0 ? void 0 : _b.outputs[relativeFilePath]) === null || _c === void 0 ? void 0 : _c.entryPoint;
+        const entryPoint = (_d = (_c = codeResults.metafile) === null || _c === void 0 ? void 0 : _c.outputs[relativeFilePath]) === null || _d === void 0 ? void 0 : _d.entryPoint;
         outputFile.path = relativeFilePath;
         if (entryPoint) {
             // An entryPoint value indicates an initial file
             initialFiles.push({
                 file: outputFile.path,
-                name: (_d = entryPointNameLookup.get(entryPoint)) !== null && _d !== void 0 ? _d : '',
+                // The first part of the filename is the name of file (e.g., "polyfills" for "polyfills.7S5G3MDY.js")
+                name: path.basename(outputFile.path).split('.')[0],
                 extension: path.extname(outputFile.path),
             });
         }
@@ -127,18 +123,14 @@ async function buildEsbuildBrowser(options, context) {
     initialFiles.push(...styleResults.initialFiles);
     // Return if the global stylesheet bundling has errors
     if (styleResults.errors.length) {
-        return { success: false };
+        return new ExecutionResult(false, codeResults.rebuild, codeBundleCache);
     }
     // Generate index HTML file
-    if (options.index) {
-        const entrypoints = (0, package_chunk_sort_1.generateEntryPoints)({
-            scripts: (_e = options.scripts) !== null && _e !== void 0 ? _e : [],
-            styles: (_f = options.styles) !== null && _f !== void 0 ? _f : [],
-        });
+    if (indexHtmlOptions) {
         // Create an index HTML generator that reads from the in-memory output files
         const indexHtmlGenerator = new index_html_generator_1.IndexHtmlGenerator({
-            indexPath: path.join(context.workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)),
-            entrypoints,
+            indexPath: indexHtmlOptions.input,
+            entrypoints: indexHtmlOptions.insertionOrder,
             sri: options.subresourceIntegrity,
             optimization: optimizationOptions,
             crossOrigin: options.crossOrigin,
@@ -166,29 +158,28 @@ async function buildEsbuildBrowser(options, context) {
         for (const warning of warnings) {
             context.logger.warn(warning);
         }
-        outputFiles.push(createOutputFileFromText((0, webpack_browser_config_1.getIndexOutputFile)(options.index), content));
+        outputFiles.push(createOutputFileFromText(indexHtmlOptions.output, content));
     }
     // Copy assets
     if (assets) {
         await (0, copy_assets_1.copyAssets)(assets, [outputPath], workspaceRoot);
     }
     // Write output files
-    await Promise.all(outputFiles.map((file) => fs_1.promises.writeFile(path.join(outputPath, file.path), file.contents)));
+    await Promise.all(outputFiles.map((file) => fs.writeFile(path.join(outputPath, file.path), file.contents)));
     // Augment the application with service worker support
     // TODO: This should eventually operate on the in-memory files prior to writing the output files
-    if (options.serviceWorker) {
+    if (serviceWorkerOptions) {
         try {
-            await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, workspaceRoot, outputPath, options.baseHref || '/', options.ngswConfigPath);
+            await (0, service_worker_1.augmentAppWithServiceWorkerEsbuild)(workspaceRoot, serviceWorkerOptions, outputPath, options.baseHref || '/');
         }
         catch (error) {
             context.logger.error(error instanceof Error ? error.message : `${error}`);
-            return { success: false };
+            return new ExecutionResult(false, codeResults.rebuild, codeBundleCache);
         }
     }
     context.logger.info(`Complete. [${(Date.now() - startTime) / 1000} seconds]`);
-    return { success: true };
+    return new ExecutionResult(true, codeResults.rebuild, codeBundleCache);
 }
-exports.buildEsbuildBrowser = buildEsbuildBrowser;
 function createOutputFileFromText(path, text) {
     return {
         path,
@@ -198,18 +189,12 @@ function createOutputFileFromText(path, text) {
         },
     };
 }
-async function bundleCode(workspaceRoot, entryPoints, outputNames, options, optimizationOptions, sourcemapOptions, tsconfig, target) {
-    var _a;
-    let fileReplacements;
-    if (options.fileReplacements) {
-        for (const replacement of options.fileReplacements) {
-            fileReplacements !== null && fileReplacements !== void 0 ? fileReplacements : (fileReplacements = {});
-            fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(workspaceRoot, replacement.with);
-        }
-    }
-    return (0, esbuild_1.bundle)({
+function createCodeBundleOptions(options, target, sourceFileCache) {
+    const { workspaceRoot, entryPoints, optimizationOptions, sourcemapOptions, tsconfig, outputNames, fileReplacements, externalDependencies, preserveSymlinks, stylePreprocessorOptions, advancedOptimizations, } = options;
+    return {
         absWorkingDir: workspaceRoot,
         bundle: true,
+        incremental: options.watch,
         format: 'esm',
         entryPoints,
         entryNames: outputNames.bundles,
@@ -234,10 +219,10 @@ async function bundleCode(workspaceRoot, entryPoints, outputNames, options, opti
         sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
         splitting: true,
         tsconfig,
-        external: options.externalDependencies,
+        external: externalDependencies,
         write: false,
         platform: 'browser',
-        preserveSymlinks: options.preserveSymlinks,
+        preserveSymlinks,
         plugins: [
             (0, compiler_plugin_1.createCompilerPlugin)(
             // JS/TS options
@@ -245,8 +230,9 @@ async function bundleCode(workspaceRoot, entryPoints, outputNames, options, opti
                 sourcemap: !!sourcemapOptions.scripts,
                 thirdPartySourcemaps: sourcemapOptions.vendor,
                 tsconfig,
-                advancedOptimizations: options.buildOptimizer,
+                advancedOptimizations,
                 fileReplacements,
+                sourceFileCache,
             }, 
             // Component stylesheet options
             {
@@ -258,8 +244,8 @@ async function bundleCode(workspaceRoot, entryPoints, outputNames, options, opti
                 // of sourcemap processing.
                 !!sourcemapOptions.styles && (sourcemapOptions.hidden ? false : 'inline'),
                 outputNames,
-                includePaths: (_a = options.stylePreprocessorOptions) === null || _a === void 0 ? void 0 : _a.includePaths,
-                externalDependencies: options.externalDependencies,
+                includePaths: stylePreprocessorOptions === null || stylePreprocessorOptions === void 0 ? void 0 : stylePreprocessorOptions.includePaths,
+                externalDependencies,
                 target,
             }),
         ],
@@ -267,21 +253,15 @@ async function bundleCode(workspaceRoot, entryPoints, outputNames, options, opti
             ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),
             'ngJitMode': 'false',
         },
-    });
+    };
 }
-async function bundleGlobalStylesheets(workspaceRoot, outputNames, options, optimizationOptions, sourcemapOptions, target) {
-    var _a;
+async function bundleGlobalStylesheets(options, target) {
+    const { workspaceRoot, optimizationOptions, sourcemapOptions, outputNames, globalStyles, preserveSymlinks, externalDependencies, stylePreprocessorOptions, } = options;
     const outputFiles = [];
     const initialFiles = [];
     const errors = [];
     const warnings = [];
-    // resolveGlobalStyles is temporarily reused from the Webpack builder code
-    const { entryPoints: stylesheetEntrypoints, noInjectNames } = (0, configs_1.resolveGlobalStyles)(options.styles || [], workspaceRoot, 
-    // preserveSymlinks is always true here to allow the bundler to handle the option
-    true, 
-    // skipResolution to leverage the bundler's more comprehensive resolution
-    true);
-    for (const [name, files] of Object.entries(stylesheetEntrypoints)) {
+    for (const { name, files, initial } of globalStyles) {
         const virtualEntryData = files
             .map((file) => `@import '${file.replace(/\\/g, '/')}';`)
             .join('\n');
@@ -289,10 +269,10 @@ async function bundleGlobalStylesheets(workspaceRoot, outputNames, options, opti
             workspaceRoot,
             optimization: !!optimizationOptions.styles.minify,
             sourcemap: !!sourcemapOptions.styles && (sourcemapOptions.hidden ? 'external' : true),
-            outputNames: noInjectNames.includes(name) ? { media: outputNames.media } : outputNames,
-            includePaths: (_a = options.stylePreprocessorOptions) === null || _a === void 0 ? void 0 : _a.includePaths,
-            preserveSymlinks: options.preserveSymlinks,
-            externalDependencies: options.externalDependencies,
+            outputNames: initial ? outputNames : { media: outputNames.media },
+            includePaths: stylePreprocessorOptions === null || stylePreprocessorOptions === void 0 ? void 0 : stylePreprocessorOptions.includePaths,
+            preserveSymlinks,
+            externalDependencies,
             target,
         });
         errors.push(...sheetResult.errors);
@@ -312,7 +292,7 @@ async function bundleGlobalStylesheets(workspaceRoot, outputNames, options, opti
             sheetContents = sheetContents.replace('sourceMappingURL=stdin.css.map', `sourceMappingURL=${name}.css.map`);
         }
         outputFiles.push(createOutputFileFromText(sheetPath, sheetContents));
-        if (!noInjectNames.includes(name)) {
+        if (initial) {
             initialFiles.push({
                 file: sheetPath,
                 name,
@@ -323,4 +303,81 @@ async function bundleGlobalStylesheets(workspaceRoot, outputNames, options, opti
     }
     return { outputFiles, initialFiles, errors, warnings };
 }
+/**
+ * Main execution function for the esbuild-based application builder.
+ * The options are compatible with the Webpack-based builder.
+ * @param initialOptions The browser builder options to use when setting up the application build
+ * @param context The Architect builder context object
+ * @returns An async iterable with the builder result output
+ */
+async function* buildEsbuildBrowser(initialOptions, context) {
+    var _a;
+    // Only AOT is currently supported
+    if (initialOptions.aot !== true) {
+        context.logger.error('JIT mode is currently not supported by this experimental builder. AOT mode must be used.');
+        return { success: false };
+    }
+    // Inform user of experimental status of builder and options
+    (0, experimental_warnings_1.logExperimentalWarnings)(initialOptions, context);
+    // Determine project name from builder context target
+    const projectName = (_a = context.target) === null || _a === void 0 ? void 0 : _a.project;
+    if (!projectName) {
+        context.logger.error(`The 'browser-esbuild' builder requires a target to be specified.`);
+        return { success: false };
+    }
+    const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, initialOptions);
+    // Clean output path if enabled
+    if (initialOptions.deleteOutputPath) {
+        (0, utils_1.deleteOutputDir)(normalizedOptions.workspaceRoot, initialOptions.outputPath);
+    }
+    // Create output directory if needed
+    try {
+        await fs.mkdir(normalizedOptions.outputPath, { recursive: true });
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error('Unable to create output directory: ' + e.message);
+        return { success: false };
+    }
+    // Initial build
+    let result = await execute(normalizedOptions, context);
+    yield result.output;
+    // Finish if watch mode is not enabled
+    if (!initialOptions.watch) {
+        return;
+    }
+    context.logger.info('Watch mode enabled. Watching for file changes...');
+    // Setup a watcher
+    const watcher = (0, watcher_1.createWatcher)({
+        polling: typeof initialOptions.poll === 'number',
+        interval: initialOptions.poll,
+        // Ignore the output path to avoid infinite rebuild cycles
+        ignored: [normalizedOptions.outputPath],
+    });
+    // Temporarily watch the entire project
+    watcher.add(normalizedOptions.projectRoot);
+    // Watch workspace root node modules
+    // Includes Yarn PnP manifest files (https://yarnpkg.com/advanced/pnp-spec/)
+    watcher.add(path.join(normalizedOptions.workspaceRoot, 'node_modules'));
+    watcher.add(path.join(normalizedOptions.workspaceRoot, '.pnp.cjs'));
+    watcher.add(path.join(normalizedOptions.workspaceRoot, '.pnp.data.json'));
+    // Wait for changes and rebuild as needed
+    try {
+        for await (const changes of watcher) {
+            context.logger.info('Changes detected. Rebuilding...');
+            if (initialOptions.verbose) {
+                context.logger.info(changes.toDebugString());
+            }
+            result = await execute(normalizedOptions, context, result.createRebuildState(changes));
+            yield result.output;
+        }
+    }
+    finally {
+        // Stop the watcher
+        await watcher.close();
+        // Cleanup incremental rebuild state
+        result.dispose();
+    }
+}
+exports.buildEsbuildBrowser = buildEsbuildBrowser;
 exports.default = (0, architect_1.createBuilder)(buildEsbuildBrowser);

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

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BuilderContext } from '@angular-devkit/architect';
-import { Schema as BrowserBuilderOptions } from '../browser/schema';
+import { Schema as BrowserBuilderOptions } from './schema';
+export declare type NormalizedBrowserOptions = Awaited<ReturnType<typeof normalizeOptions>>;
 /**
  * Normalize the user provided options by creating full paths for all path based options
  * and converting multi-form options into a single form that can be directly used
@@ -18,17 +19,38 @@ import { Schema as BrowserBuilderOptions } from '../browser/schema';
  * @returns An object containing normalized options required to perform the build.
  */
 export declare function normalizeOptions(context: BuilderContext, projectName: string, options: BrowserBuilderOptions): Promise<{
+    advancedOptimizations: boolean | undefined;
+    baseHref: string | undefined;
+    crossOrigin: import("./schema").CrossOrigin | undefined;
+    externalDependencies: string[] | undefined;
+    poll: number | undefined;
+    preserveSymlinks: boolean | undefined;
+    stylePreprocessorOptions: import("./schema").StylePreprocessorOptions | undefined;
+    subresourceIntegrity: boolean | undefined;
+    verbose: boolean | undefined;
+    watch: boolean | undefined;
     workspaceRoot: string;
     entryPoints: Record<string, string>;
-    entryPointNameLookup: ReadonlyMap<string, string>;
     optimizationOptions: import("../../utils").NormalizedOptimizationOptions;
     outputPath: string;
-    sourcemapOptions: import("../browser/schema").SourceMapClass;
+    sourcemapOptions: import("../..").SourceMapObject;
     tsconfig: string;
     projectRoot: string;
-    assets: import("../browser/schema").AssetPatternClass[] | undefined;
+    assets: import("../..").AssetPatternObject[] | undefined;
     outputNames: {
         bundles: string;
         media: string;
     };
+    fileReplacements: Record<string, string> | undefined;
+    globalStyles: {
+        name: string;
+        files: string[];
+        initial: boolean;
+    }[];
+    serviceWorkerOptions: string | undefined;
+    indexHtmlOptions: {
+        input: string;
+        output: string;
+        insertionOrder: import("../../utils/package-chunk-sort").EntryPointsType[];
+    } | undefined;
 }>;

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

@@ -34,7 +34,10 @@ exports.normalizeOptions = void 0;
 const path = __importStar(require("path"));
 const utils_1 = require("../../utils");
 const normalize_polyfills_1 = require("../../utils/normalize-polyfills");
-const schema_1 = require("../browser/schema");
+const package_chunk_sort_1 = require("../../utils/package-chunk-sort");
+const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
+const helpers_1 = require("../../webpack/utils/helpers");
+const schema_1 = require("./schema");
 /**
  * Normalize the user provided options by creating full paths for all path based options
  * and converting multi-form options into a single form that can be directly used
@@ -46,7 +49,7 @@ const schema_1 = require("../browser/schema");
  * @returns An object containing normalized options required to perform the build.
  */
 async function normalizeOptions(context, projectName, options) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g;
     const workspaceRoot = context.workspaceRoot;
     const projectMetadata = await context.getProjectMetadata(projectName);
     const projectRoot = path.join(workspaceRoot, (_a = projectMetadata.root) !== null && _a !== void 0 ? _a : '');
@@ -76,6 +79,27 @@ async function normalizeOptions(context, projectName, options) {
     if (options.resourcesOutputPath) {
         outputNames.media = path.join(options.resourcesOutputPath, outputNames.media);
     }
+    let fileReplacements;
+    if (options.fileReplacements) {
+        for (const replacement of options.fileReplacements) {
+            fileReplacements !== null && fileReplacements !== void 0 ? fileReplacements : (fileReplacements = {});
+            fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(workspaceRoot, replacement.with);
+        }
+    }
+    const globalStyles = [];
+    if ((_e = options.styles) === null || _e === void 0 ? void 0 : _e.length) {
+        const { entryPoints: stylesheetEntrypoints, noInjectNames } = (0, helpers_1.normalizeGlobalStyles)(options.styles || []);
+        for (const [name, files] of Object.entries(stylesheetEntrypoints)) {
+            globalStyles.push({ name, files, initial: !noInjectNames.includes(name) });
+        }
+    }
+    let serviceWorkerOptions;
+    if (options.serviceWorker) {
+        // If ngswConfigPath is not specified, the default is 'ngsw-config.json' within the project root
+        serviceWorkerOptions = options.ngswConfigPath
+            ? path.join(workspaceRoot, options.ngswConfigPath)
+            : path.join(projectRoot, 'ngsw-config.json');
+    }
     // Setup bundler entry points
     const entryPoints = {
         main: mainEntryPoint,
@@ -83,12 +107,35 @@ async function normalizeOptions(context, projectName, options) {
     if (polyfillsEntryPoint) {
         entryPoints['polyfills'] = polyfillsEntryPoint;
     }
-    // Create reverse lookup used during index HTML generation
-    const entryPointNameLookup = new Map(Object.entries(entryPoints).map(([name, filePath]) => [path.relative(workspaceRoot, filePath), name]));
+    let indexHtmlOptions;
+    if (options.index) {
+        indexHtmlOptions = {
+            input: path.join(workspaceRoot, (0, webpack_browser_config_1.getIndexInputFile)(options.index)),
+            // The output file will be created within the configured output path
+            output: (0, webpack_browser_config_1.getIndexOutputFile)(options.index),
+            // TODO: Use existing information from above to create the insertion order
+            insertionOrder: (0, package_chunk_sort_1.generateEntryPoints)({
+                scripts: (_f = options.scripts) !== null && _f !== void 0 ? _f : [],
+                styles: (_g = options.styles) !== null && _g !== void 0 ? _g : [],
+            }),
+        };
+    }
+    // Initial options to keep
+    const { baseHref, buildOptimizer, crossOrigin, externalDependencies, poll, preserveSymlinks, stylePreprocessorOptions, subresourceIntegrity, verbose, watch, } = options;
+    // Return all the normalized options
     return {
+        advancedOptimizations: buildOptimizer,
+        baseHref,
+        crossOrigin,
+        externalDependencies,
+        poll,
+        preserveSymlinks,
+        stylePreprocessorOptions,
+        subresourceIntegrity,
+        verbose,
+        watch,
         workspaceRoot,
         entryPoints,
-        entryPointNameLookup,
         optimizationOptions,
         outputPath,
         sourcemapOptions,
@@ -96,6 +143,10 @@ async function normalizeOptions(context, projectName, options) {
         projectRoot,
         assets,
         outputNames,
+        fileReplacements,
+        globalStyles,
+        serviceWorkerOptions,
+        indexHtmlOptions,
     };
 }
 exports.normalizeOptions = normalizeOptions;

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

@@ -0,0 +1,23 @@
+/**
+ * @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
+ */
+export declare class ChangedFiles {
+    readonly added: Set<string>;
+    readonly modified: Set<string>;
+    readonly removed: Set<string>;
+    toDebugString(): string;
+}
+export interface BuildWatcher extends AsyncIterableIterator<ChangedFiles> {
+    add(paths: string | string[]): void;
+    remove(paths: string | string[]): void;
+    close(): Promise<void>;
+}
+export declare function createWatcher(options?: {
+    polling?: boolean;
+    interval?: number;
+    ignored?: string[];
+}): BuildWatcher;

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

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatcher = exports.ChangedFiles = void 0;
+const chokidar_1 = require("chokidar");
+class ChangedFiles {
+    constructor() {
+        this.added = new Set();
+        this.modified = new Set();
+        this.removed = new Set();
+    }
+    toDebugString() {
+        const content = {
+            added: Array.from(this.added),
+            modified: Array.from(this.modified),
+            removed: Array.from(this.removed),
+        };
+        return JSON.stringify(content, null, 2);
+    }
+}
+exports.ChangedFiles = ChangedFiles;
+function createWatcher(options) {
+    const watcher = new chokidar_1.FSWatcher({
+        ...options,
+        disableGlobbing: true,
+        ignoreInitial: true,
+    });
+    const nextQueue = [];
+    let currentChanges;
+    watcher.on('all', (event, path) => {
+        switch (event) {
+            case 'add':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.added.add(path);
+                break;
+            case 'change':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.modified.add(path);
+                break;
+            case 'unlink':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.removed.add(path);
+                break;
+            default:
+                return;
+        }
+        const next = nextQueue.shift();
+        if (next) {
+            const value = currentChanges;
+            currentChanges = undefined;
+            next(value);
+        }
+    });
+    return {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        async next() {
+            if (currentChanges && nextQueue.length === 0) {
+                const result = { value: currentChanges };
+                currentChanges = undefined;
+                return result;
+            }
+            return new Promise((resolve) => {
+                nextQueue.push((value) => resolve(value ? { value } : { done: true, value }));
+            });
+        },
+        add(paths) {
+            watcher.add(paths);
+        },
+        remove(paths) {
+            watcher.unwatch(paths);
+        },
+        async close() {
+            try {
+                await watcher.close();
+            }
+            finally {
+                let next;
+                while ((next = nextQueue.shift()) !== undefined) {
+                    next();
+                }
+            }
+        },
+    };
+}
+exports.createWatcher = createWatcher;

package/src/builders/karma/index.d.ts

@@ -23,5 +23,5 @@ export declare function execute(options: KarmaBuilderOptions, context: BuilderCo
     karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions;
 }): Observable<BuilderOutput>;
 export { KarmaBuilderOptions };
-declare const _default: import("@angular-devkit/architect/src/internal").Builder<Record<string, string> & KarmaBuilderOptions & import("../../../../core/src").JsonObject>;
+declare const _default: import("@angular-devkit/architect/src/internal").Builder<Record<string, string> & KarmaBuilderOptions & import("@angular-devkit/core").JsonObject>;
 export default _default;