@angular-devkit/build-angular 16.1.0-rc.0 → 16.1.1

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

@@ -0,0 +1,205 @@
+"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
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BundlerContext_esbuildContext, _BundlerContext_esbuildOptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundlerContext = void 0;
+const esbuild_1 = require("esbuild");
+const node_path_1 = require("node:path");
+/**
+ * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild.
+ * @param value A potential esbuild BuildFailure error object.
+ * @returns `true` if the object is determined to be a BuildFailure object; otherwise, `false`.
+ */
+function isEsBuildFailure(value) {
+    return !!value && typeof value === 'object' && 'errors' in value && 'warnings' in value;
+}
+class BundlerContext {
+    constructor(workspaceRoot, incremental, options, initialFilter) {
+        this.workspaceRoot = workspaceRoot;
+        this.incremental = incremental;
+        this.initialFilter = initialFilter;
+        _BundlerContext_esbuildContext.set(this, void 0);
+        _BundlerContext_esbuildOptions.set(this, void 0);
+        this.watchFiles = new Set();
+        __classPrivateFieldSet(this, _BundlerContext_esbuildOptions, {
+            ...options,
+            metafile: true,
+            write: false,
+        }, "f");
+    }
+    static async bundleAll(contexts) {
+        const individualResults = await Promise.all([...contexts].map((context) => context.bundle()));
+        // Return directly if only one result
+        if (individualResults.length === 1) {
+            return individualResults[0];
+        }
+        let errors;
+        const warnings = [];
+        const metafile = { inputs: {}, outputs: {} };
+        const initialFiles = new Map();
+        const outputFiles = [];
+        for (const result of individualResults) {
+            warnings.push(...result.warnings);
+            if (result.errors) {
+                errors ?? (errors = []);
+                errors.push(...result.errors);
+                continue;
+            }
+            // Combine metafiles used for the stats option as well as bundle budgets and console output
+            if (result.metafile) {
+                metafile.inputs = { ...metafile.inputs, ...result.metafile.inputs };
+                metafile.outputs = { ...metafile.outputs, ...result.metafile.outputs };
+            }
+            result.initialFiles.forEach((value, key) => initialFiles.set(key, value));
+            outputFiles.push(...result.outputFiles);
+        }
+        if (errors !== undefined) {
+            return { errors, warnings };
+        }
+        return {
+            errors,
+            warnings,
+            metafile,
+            initialFiles,
+            outputFiles,
+        };
+    }
+    /**
+     * Executes the esbuild build function and normalizes the build result in the event of a
+     * build failure that results in no output being generated.
+     * All builds use the `write` option with a value of `false` to allow for the output files
+     * build result array to be populated.
+     *
+     * @returns If output files are generated, the full esbuild BuildResult; if not, the
+     * warnings and errors for the attempted build.
+     */
+    async bundle() {
+        let result;
+        try {
+            if (__classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f")) {
+                // Rebuild using the existing incremental build context
+                result = await __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f").rebuild();
+            }
+            else if (this.incremental) {
+                // Create an incremental build context and perform the first build.
+                // Context creation does not perform a build.
+                __classPrivateFieldSet(this, _BundlerContext_esbuildContext, await (0, esbuild_1.context)(__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f")), "f");
+                result = await __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f").rebuild();
+            }
+            else {
+                // For non-incremental builds, perform a single build
+                result = await (0, esbuild_1.build)(__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f"));
+            }
+        }
+        catch (failure) {
+            // Build failures will throw an exception which contains errors/warnings
+            if (isEsBuildFailure(failure)) {
+                return failure;
+            }
+            else {
+                throw failure;
+            }
+        }
+        // Update files that should be watched.
+        // While this should technically not be linked to incremental mode, incremental is only
+        // currently enabled with watch mode where watch files are needed.
+        if (this.incremental) {
+            this.watchFiles.clear();
+            // Add input files except virtual angular files which do not exist on disk
+            Object.keys(result.metafile.inputs)
+                .filter((input) => !input.startsWith('angular:'))
+                .forEach((input) => this.watchFiles.add((0, node_path_1.join)(this.workspaceRoot, input)));
+        }
+        // Return if the build encountered any errors
+        if (result.errors.length) {
+            return {
+                errors: result.errors,
+                warnings: result.warnings,
+            };
+        }
+        // Find all initial files
+        const initialFiles = new Map();
+        for (const outputFile of result.outputFiles) {
+            // Entries in the metafile are relative to the `absWorkingDir` option which is set to the workspaceRoot
+            const relativeFilePath = (0, node_path_1.relative)(this.workspaceRoot, outputFile.path);
+            const entryPoint = result.metafile.outputs[relativeFilePath]?.entryPoint;
+            outputFile.path = relativeFilePath;
+            if (entryPoint) {
+                // The first part of the filename is the name of file (e.g., "polyfills" for "polyfills.7S5G3MDY.js")
+                const name = (0, node_path_1.basename)(relativeFilePath).split('.', 1)[0];
+                // Entry points are only styles or scripts
+                const type = (0, node_path_1.extname)(relativeFilePath) === '.css' ? 'style' : 'script';
+                // Only entrypoints with an entry in the options are initial files.
+                // Dynamic imports also have an entryPoint value in the meta file.
+                if (__classPrivateFieldGet(this, _BundlerContext_esbuildOptions, "f").entryPoints?.[name]) {
+                    // An entryPoint value indicates an initial file
+                    const record = {
+                        name,
+                        type,
+                        entrypoint: true,
+                    };
+                    if (!this.initialFilter || this.initialFilter(record)) {
+                        initialFiles.set(relativeFilePath, record);
+                    }
+                }
+            }
+        }
+        // Analyze for transitive initial files
+        const files = [...initialFiles.keys()];
+        for (const file of files) {
+            for (const initialImport of result.metafile.outputs[file].imports) {
+                if (initialFiles.has(initialImport.path)) {
+                    continue;
+                }
+                if (initialImport.kind === 'import-statement' || initialImport.kind === 'import-rule') {
+                    const record = {
+                        type: initialImport.kind === 'import-rule' ? 'style' : 'script',
+                        entrypoint: false,
+                        external: initialImport.external,
+                    };
+                    if (!this.initialFilter || this.initialFilter(record)) {
+                        initialFiles.set(initialImport.path, record);
+                    }
+                    if (!initialImport.external) {
+                        files.push(initialImport.path);
+                    }
+                }
+            }
+        }
+        // Return the successful build results
+        return { ...result, initialFiles, errors: undefined };
+    }
+    /**
+     * Disposes incremental build resources present in the context.
+     *
+     * @returns A promise that resolves when disposal is complete.
+     */
+    async dispose() {
+        try {
+            return __classPrivateFieldGet(this, _BundlerContext_esbuildContext, "f")?.dispose();
+        }
+        finally {
+            __classPrivateFieldSet(this, _BundlerContext_esbuildContext, undefined, "f");
+        }
+    }
+}
+exports.BundlerContext = BundlerContext;
+_BundlerContext_esbuildContext = new WeakMap(), _BundlerContext_esbuildOptions = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundler-context.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/bundler-context.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  BuildContext,\n  BuildFailure,\n  BuildOptions,\n  Message,\n  Metafile,\n  OutputFile,\n  build,\n  context,\n} from 'esbuild';\nimport { basename, extname, join, relative } from 'node:path';\n\nexport type BundleContextResult =\n  | { errors: Message[]; warnings: Message[] }\n  | {\n      errors: undefined;\n      warnings: Message[];\n      metafile: Metafile;\n      outputFiles: OutputFile[];\n      initialFiles: Map<string, InitialFileRecord>;\n    };\n\nexport interface InitialFileRecord {\n  entrypoint: boolean;\n  name?: string;\n  type: 'script' | 'style';\n  external?: boolean;\n}\n\n/**\n * Determines if an unknown value is an esbuild BuildFailure error object thrown by esbuild.\n * @param value A potential esbuild BuildFailure error object.\n * @returns `true` if the object is determined to be a BuildFailure object; otherwise, `false`.\n */\nfunction isEsBuildFailure(value: unknown): value is BuildFailure {\n  return !!value && typeof value === 'object' && 'errors' in value && 'warnings' in value;\n}\n\nexport class BundlerContext {\n  #esbuildContext?: BuildContext<{ metafile: true; write: false }>;\n  #esbuildOptions: BuildOptions & { metafile: true; write: false };\n\n  readonly watchFiles = new Set<string>();\n\n  constructor(\n    private workspaceRoot: string,\n    private incremental: boolean,\n    options: BuildOptions,\n    private initialFilter?: (initial: Readonly<InitialFileRecord>) => boolean,\n  ) {\n    this.#esbuildOptions = {\n      ...options,\n      metafile: true,\n      write: false,\n    };\n  }\n\n  static async bundleAll(contexts: Iterable<BundlerContext>): Promise<BundleContextResult> {\n    const individualResults = await Promise.all([...contexts].map((context) => context.bundle()));\n\n    // Return directly if only one result\n    if (individualResults.length === 1) {\n      return individualResults[0];\n    }\n\n    let errors: Message[] | undefined;\n    const warnings: Message[] = [];\n    const metafile: Metafile = { inputs: {}, outputs: {} };\n    const initialFiles = new Map<string, InitialFileRecord>();\n    const outputFiles = [];\n    for (const result of individualResults) {\n      warnings.push(...result.warnings);\n      if (result.errors) {\n        errors ??= [];\n        errors.push(...result.errors);\n        continue;\n      }\n\n      // Combine metafiles used for the stats option as well as bundle budgets and console output\n      if (result.metafile) {\n        metafile.inputs = { ...metafile.inputs, ...result.metafile.inputs };\n        metafile.outputs = { ...metafile.outputs, ...result.metafile.outputs };\n      }\n\n      result.initialFiles.forEach((value, key) => initialFiles.set(key, value));\n      outputFiles.push(...result.outputFiles);\n    }\n\n    if (errors !== undefined) {\n      return { errors, warnings };\n    }\n\n    return {\n      errors,\n      warnings,\n      metafile,\n      initialFiles,\n      outputFiles,\n    };\n  }\n\n  /**\n   * Executes the esbuild build function and normalizes the build result in the event of a\n   * build failure that results in no output being generated.\n   * All builds use the `write` option with a value of `false` to allow for the output files\n   * build result array to be populated.\n   *\n   * @returns If output files are generated, the full esbuild BuildResult; if not, the\n   * warnings and errors for the attempted build.\n   */\n  async bundle(): Promise<BundleContextResult> {\n    let result;\n    try {\n      if (this.#esbuildContext) {\n        // Rebuild using the existing incremental build context\n        result = await this.#esbuildContext.rebuild();\n      } else if (this.incremental) {\n        // Create an incremental build context and perform the first build.\n        // Context creation does not perform a build.\n        this.#esbuildContext = await context(this.#esbuildOptions);\n        result = await this.#esbuildContext.rebuild();\n      } else {\n        // For non-incremental builds, perform a single build\n        result = await build(this.#esbuildOptions);\n      }\n    } catch (failure) {\n      // Build failures will throw an exception which contains errors/warnings\n      if (isEsBuildFailure(failure)) {\n        return failure;\n      } else {\n        throw failure;\n      }\n    }\n\n    // Update files that should be watched.\n    // While this should technically not be linked to incremental mode, incremental is only\n    // currently enabled with watch mode where watch files are needed.\n    if (this.incremental) {\n      this.watchFiles.clear();\n      // Add input files except virtual angular files which do not exist on disk\n      Object.keys(result.metafile.inputs)\n        .filter((input) => !input.startsWith('angular:'))\n        .forEach((input) => this.watchFiles.add(join(this.workspaceRoot, input)));\n    }\n\n    // Return if the build encountered any errors\n    if (result.errors.length) {\n      return {\n        errors: result.errors,\n        warnings: result.warnings,\n      };\n    }\n\n    // Find all initial files\n    const initialFiles = new Map<string, InitialFileRecord>();\n    for (const outputFile of result.outputFiles) {\n      // Entries in the metafile are relative to the `absWorkingDir` option which is set to the workspaceRoot\n      const relativeFilePath = relative(this.workspaceRoot, outputFile.path);\n      const entryPoint = result.metafile.outputs[relativeFilePath]?.entryPoint;\n\n      outputFile.path = relativeFilePath;\n\n      if (entryPoint) {\n        // The first part of the filename is the name of file (e.g., \"polyfills\" for \"polyfills.7S5G3MDY.js\")\n        const name = basename(relativeFilePath).split('.', 1)[0];\n        // Entry points are only styles or scripts\n        const type = extname(relativeFilePath) === '.css' ? 'style' : 'script';\n\n        // Only entrypoints with an entry in the options are initial files.\n        // Dynamic imports also have an entryPoint value in the meta file.\n        if ((this.#esbuildOptions.entryPoints as Record<string, string>)?.[name]) {\n          // An entryPoint value indicates an initial file\n          const record: InitialFileRecord = {\n            name,\n            type,\n            entrypoint: true,\n          };\n\n          if (!this.initialFilter || this.initialFilter(record)) {\n            initialFiles.set(relativeFilePath, record);\n          }\n        }\n      }\n    }\n\n    // Analyze for transitive initial files\n    const files = [...initialFiles.keys()];\n    for (const file of files) {\n      for (const initialImport of result.metafile.outputs[file].imports) {\n        if (initialFiles.has(initialImport.path)) {\n          continue;\n        }\n\n        if (initialImport.kind === 'import-statement' || initialImport.kind === 'import-rule') {\n          const record: InitialFileRecord = {\n            type: initialImport.kind === 'import-rule' ? 'style' : 'script',\n            entrypoint: false,\n            external: initialImport.external,\n          };\n\n          if (!this.initialFilter || this.initialFilter(record)) {\n            initialFiles.set(initialImport.path, record);\n          }\n\n          if (!initialImport.external) {\n            files.push(initialImport.path);\n          }\n        }\n      }\n    }\n\n    // Return the successful build results\n    return { ...result, initialFiles, errors: undefined };\n  }\n\n  /**\n   * Disposes incremental build resources present in the context.\n   *\n   * @returns A promise that resolves when disposal is complete.\n   */\n  async dispose(): Promise<void> {\n    try {\n      return this.#esbuildContext?.dispose();\n    } finally {\n      this.#esbuildContext = undefined;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { OutputFile } from 'esbuild';
+import type { ChangedFiles } from '../../tools/esbuild/watcher';
+import type { SourceFileCache } from './angular/compiler-plugin';
+import type { BundlerContext } from './bundler-context';
+export interface RebuildState {
+    rebuildContexts: BundlerContext[];
+    codeBundleCache?: SourceFileCache;
+    fileChanges: ChangedFiles;
+}
+/**
+ * Represents the result of a single builder execute call.
+ */
+export declare class ExecutionResult {
+    private rebuildContexts;
+    private codeBundleCache?;
+    readonly outputFiles: OutputFile[];
+    readonly assetFiles: {
+        source: string;
+        destination: string;
+    }[];
+    constructor(rebuildContexts: BundlerContext[], codeBundleCache?: SourceFileCache | undefined);
+    addOutputFile(path: string, content: string): void;
+    get output(): {
+        success: boolean;
+    };
+    get outputWithFiles(): {
+        success: boolean;
+        outputFiles: OutputFile[];
+        assetFiles: {
+            source: string;
+            destination: string;
+        }[];
+    };
+    get watchFiles(): string[];
+    createRebuildState(fileChanges: ChangedFiles): RebuildState;
+    dispose(): Promise<void>;
+}

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

@@ -0,0 +1,57 @@
+"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.ExecutionResult = void 0;
+const utils_1 = require("./utils");
+/**
+ * Represents the result of a single builder execute call.
+ */
+class ExecutionResult {
+    constructor(rebuildContexts, codeBundleCache) {
+        this.rebuildContexts = rebuildContexts;
+        this.codeBundleCache = codeBundleCache;
+        this.outputFiles = [];
+        this.assetFiles = [];
+    }
+    addOutputFile(path, content) {
+        this.outputFiles.push((0, utils_1.createOutputFileFromText)(path, content));
+    }
+    get output() {
+        return {
+            success: this.outputFiles.length > 0,
+        };
+    }
+    get outputWithFiles() {
+        return {
+            success: this.outputFiles.length > 0,
+            outputFiles: this.outputFiles,
+            assetFiles: this.assetFiles,
+        };
+    }
+    get watchFiles() {
+        const files = this.rebuildContexts.flatMap((context) => [...context.watchFiles]);
+        if (this.codeBundleCache?.referencedFiles) {
+            files.push(...this.codeBundleCache.referencedFiles);
+        }
+        return files;
+    }
+    createRebuildState(fileChanges) {
+        this.codeBundleCache?.invalidate([...fileChanges.modified, ...fileChanges.removed]);
+        return {
+            rebuildContexts: this.rebuildContexts,
+            codeBundleCache: this.codeBundleCache,
+            fileChanges,
+        };
+    }
+    async dispose() {
+        await Promise.allSettled(this.rebuildContexts.map((context) => context.dispose()));
+    }
+}
+exports.ExecutionResult = ExecutionResult;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,141 @@
+"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.checkCommonJSModules = void 0;
+/**
+ * Checks the input files of a build to determine if any of the files included
+ * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized
+ * in ways that CommonJS and other module formats cannot. The esbuild metafile
+ * information is used as the basis for the analysis as it contains information
+ * for each input file including its respective format.
+ *
+ * If any allowed dependencies are provided via the `allowedCommonJsDependencies`
+ * parameter, both the direct import and any deep imports will be ignored and no
+ * diagnostic will be generated.
+ *
+ * If a module has been issued a diagnostic message, then all descendant modules
+ * will not be checked. This prevents a potential massive amount of inactionable
+ * messages since the initial module import is the cause of the problem.
+ *
+ * @param metafile An esbuild metafile object to check.
+ * @param allowedCommonJsDependencies An optional list of allowed dependencies.
+ * @returns Zero or more diagnostic messages for any non-ESM modules.
+ */
+function checkCommonJSModules(metafile, allowedCommonJsDependencies) {
+    const messages = [];
+    const allowedRequests = new Set(allowedCommonJsDependencies);
+    // Ignore Angular locale definitions which are currently UMD
+    allowedRequests.add('@angular/common/locales');
+    // Ignore zone.js due to it currently being built with a UMD like structure.
+    // Once the build output is updated to be fully ESM, this can be removed.
+    allowedRequests.add('zone.js');
+    // Find all entry points that contain code (JS/TS)
+    const files = [];
+    for (const { entryPoint } of Object.values(metafile.outputs)) {
+        if (!entryPoint) {
+            continue;
+        }
+        if (!isPathCode(entryPoint)) {
+            continue;
+        }
+        files.push(entryPoint);
+    }
+    // Track seen files so they are only analyzed once.
+    // Bundler runtime code is also ignored since it cannot be actionable.
+    const seenFiles = new Set(['<runtime>']);
+    // Analyze the files present by walking the import graph
+    let currentFile;
+    while ((currentFile = files.shift())) {
+        const input = metafile.inputs[currentFile];
+        for (const imported of input.imports) {
+            // Ignore imports that were already seen or not originally in the code (bundler injected)
+            if (!imported.original || seenFiles.has(imported.path)) {
+                continue;
+            }
+            seenFiles.add(imported.path);
+            // Only check actual code files
+            if (!isPathCode(imported.path)) {
+                continue;
+            }
+            // Check if non-relative import is ESM format and issue a diagnostic if the file is not allowed
+            if (!isPotentialRelative(imported.original) &&
+                metafile.inputs[imported.path].format !== 'esm') {
+                const request = imported.original;
+                let notAllowed = true;
+                if (allowedRequests.has(request)) {
+                    notAllowed = false;
+                }
+                else {
+                    // Check for deep imports of allowed requests
+                    for (const allowed of allowedRequests) {
+                        if (request.startsWith(allowed + '/')) {
+                            notAllowed = false;
+                            break;
+                        }
+                    }
+                }
+                if (notAllowed) {
+                    // Issue a diagnostic message and skip all descendants since they are also most
+                    // likely not ESM but solved by addressing this import.
+                    messages.push(createCommonJSModuleError(request, currentFile));
+                    continue;
+                }
+            }
+            // Add the path so that its imports can be checked
+            files.push(imported.path);
+        }
+    }
+    return messages;
+}
+exports.checkCommonJSModules = checkCommonJSModules;
+/**
+ * Determines if a file path has an extension that is a JavaScript or TypeScript
+ * code file.
+ *
+ * @param name A path to check for code file extensions.
+ * @returns True, if a code file path; false, otherwise.
+ */
+function isPathCode(name) {
+    return /\.[cm]?[jt]sx?$/.test(name);
+}
+/**
+ * Test an import module specifier to determine if the string potentially references a relative file.
+ * npm packages should not start with a period so if the first character is a period than it is not a
+ * package. While this is sufficient for the use case in the CommmonJS checker, only checking the
+ * first character does not definitely indicate the specifier is a relative path.
+ *
+ * @param specifier An import module specifier.
+ * @returns True, if specifier is potentially relative; false, otherwise.
+ */
+function isPotentialRelative(specifier) {
+    if (specifier[0] === '.') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Creates an esbuild diagnostic message for a given non-ESM module request.
+ *
+ * @param request The requested non-ESM module name.
+ * @param importer The path of the file containing the import.
+ * @returns A message representing the diagnostic.
+ */
+function createCommonJSModuleError(request, importer) {
+    const error = {
+        text: `Module '${request}' used by '${importer}' is not ESM`,
+        notes: [
+            {
+                text: 'CommonJS or AMD dependencies can cause optimization bailouts.\n' +
+                    'For more information see: https://angular.io/guide/build#configuring-commonjs-dependencies',
+            },
+        ],
+    };
+    return error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commonjs-checker.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/tools/esbuild/commonjs-checker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { Metafile, PartialMessage } from 'esbuild';\n\n/**\n * Checks the input files of a build to determine if any of the files included\n * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized\n * in ways that CommonJS and other module formats cannot. The esbuild metafile\n * information is used as the basis for the analysis as it contains information\n * for each input file including its respective format.\n *\n * If any allowed dependencies are provided via the `allowedCommonJsDependencies`\n * parameter, both the direct import and any deep imports will be ignored and no\n * diagnostic will be generated.\n *\n * If a module has been issued a diagnostic message, then all descendant modules\n * will not be checked. This prevents a potential massive amount of inactionable\n * messages since the initial module import is the cause of the problem.\n *\n * @param metafile An esbuild metafile object to check.\n * @param allowedCommonJsDependencies An optional list of allowed dependencies.\n * @returns Zero or more diagnostic messages for any non-ESM modules.\n */\nexport function checkCommonJSModules(\n  metafile: Metafile,\n  allowedCommonJsDependencies?: string[],\n): PartialMessage[] {\n  const messages: PartialMessage[] = [];\n  const allowedRequests = new Set(allowedCommonJsDependencies);\n\n  // Ignore Angular locale definitions which are currently UMD\n  allowedRequests.add('@angular/common/locales');\n\n  // Ignore zone.js due to it currently being built with a UMD like structure.\n  // Once the build output is updated to be fully ESM, this can be removed.\n  allowedRequests.add('zone.js');\n\n  // Find all entry points that contain code (JS/TS)\n  const files: string[] = [];\n  for (const { entryPoint } of Object.values(metafile.outputs)) {\n    if (!entryPoint) {\n      continue;\n    }\n    if (!isPathCode(entryPoint)) {\n      continue;\n    }\n\n    files.push(entryPoint);\n  }\n\n  // Track seen files so they are only analyzed once.\n  // Bundler runtime code is also ignored since it cannot be actionable.\n  const seenFiles = new Set<string>(['<runtime>']);\n\n  // Analyze the files present by walking the import graph\n  let currentFile: string | undefined;\n  while ((currentFile = files.shift())) {\n    const input = metafile.inputs[currentFile];\n\n    for (const imported of input.imports) {\n      // Ignore imports that were already seen or not originally in the code (bundler injected)\n      if (!imported.original || seenFiles.has(imported.path)) {\n        continue;\n      }\n      seenFiles.add(imported.path);\n\n      // Only check actual code files\n      if (!isPathCode(imported.path)) {\n        continue;\n      }\n\n      // Check if non-relative import is ESM format and issue a diagnostic if the file is not allowed\n      if (\n        !isPotentialRelative(imported.original) &&\n        metafile.inputs[imported.path].format !== 'esm'\n      ) {\n        const request = imported.original;\n\n        let notAllowed = true;\n        if (allowedRequests.has(request)) {\n          notAllowed = false;\n        } else {\n          // Check for deep imports of allowed requests\n          for (const allowed of allowedRequests) {\n            if (request.startsWith(allowed + '/')) {\n              notAllowed = false;\n              break;\n            }\n          }\n        }\n\n        if (notAllowed) {\n          // Issue a diagnostic message and skip all descendants since they are also most\n          // likely not ESM but solved by addressing this import.\n          messages.push(createCommonJSModuleError(request, currentFile));\n          continue;\n        }\n      }\n\n      // Add the path so that its imports can be checked\n      files.push(imported.path);\n    }\n  }\n\n  return messages;\n}\n\n/**\n * Determines if a file path has an extension that is a JavaScript or TypeScript\n * code file.\n *\n * @param name A path to check for code file extensions.\n * @returns True, if a code file path; false, otherwise.\n */\nfunction isPathCode(name: string): boolean {\n  return /\\.[cm]?[jt]sx?$/.test(name);\n}\n\n/**\n * Test an import module specifier to determine if the string potentially references a relative file.\n * npm packages should not start with a period so if the first character is a period than it is not a\n * package. While this is sufficient for the use case in the CommmonJS checker, only checking the\n * first character does not definitely indicate the specifier is a relative path.\n *\n * @param specifier An import module specifier.\n * @returns True, if specifier is potentially relative; false, otherwise.\n */\nfunction isPotentialRelative(specifier: string): boolean {\n  if (specifier[0] === '.') {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Creates an esbuild diagnostic message for a given non-ESM module request.\n *\n * @param request The requested non-ESM module name.\n * @param importer The path of the file containing the import.\n * @returns A message representing the diagnostic.\n */\nfunction createCommonJSModuleError(request: string, importer: string): PartialMessage {\n  const error = {\n    text: `Module '${request}' used by '${importer}' is not ESM`,\n    notes: [\n      {\n        text:\n          'CommonJS or AMD dependencies can cause optimization bailouts.\\n' +\n          'For more information see: https://angular.io/guide/build#configuring-commonjs-dependencies',\n      },\n    ],\n  };\n\n  return error;\n}\n"]}

package/src/tools/esbuild/external-packages-plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import type { Plugin } from 'esbuild';
+/**
+ * Creates a plugin that marks any resolved path as external if it is within a node modules directory.
+ * This is used instead of the esbuild `packages` option to avoid marking bare specifiers that use
+ * tsconfig path mapping to resolve to a workspace relative path. This is common for monorepos that
+ * contain libraries that are built along with the application. These libraries should not be considered
+ *
+ * @returns An esbuild plugin.
+ */
+export declare function createExternalPackagesPlugin(): Plugin;

package/src/tools/esbuild/external-packages-plugin.js

@@ -0,0 +1,49 @@
+"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.createExternalPackagesPlugin = void 0;
+const EXTERNAL_PACKAGE_RESOLUTION = Symbol('EXTERNAL_PACKAGE_RESOLUTION');
+/**
+ * Creates a plugin that marks any resolved path as external if it is within a node modules directory.
+ * This is used instead of the esbuild `packages` option to avoid marking bare specifiers that use
+ * tsconfig path mapping to resolve to a workspace relative path. This is common for monorepos that
+ * contain libraries that are built along with the application. These libraries should not be considered
+ *
+ * @returns An esbuild plugin.
+ */
+function createExternalPackagesPlugin() {
+    return {
+        name: 'angular-external-packages',
+        setup(build) {
+            build.onResolve({ filter: /./ }, async (args) => {
+                if (args.pluginData?.[EXTERNAL_PACKAGE_RESOLUTION]) {
+                    return null;
+                }
+                const { importer, kind, resolveDir, namespace, pluginData = {} } = args;
+                pluginData[EXTERNAL_PACKAGE_RESOLUTION] = true;
+                const result = await build.resolve(args.path, {
+                    importer,
+                    kind,
+                    namespace,
+                    pluginData,
+                    resolveDir,
+                });
+                if (result.path && /[\\/]node_modules[\\/]/.test(result.path)) {
+                    return {
+                        path: args.path,
+                        external: true,
+                    };
+                }
+                return result;
+            });
+        },
+    };
+}
+exports.createExternalPackagesPlugin = createExternalPackagesPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/{builders/browser-esbuild → tools/esbuild}/global-scripts.d.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type { BuildOptions } from 'esbuild';
+import type { NormalizedBrowserOptions } from '../../builders/browser-esbuild/options';
 import { LoadResultCache } from './load-result-cache';
-import type { NormalizedBrowserOptions } from './options';
 /**
  * Create an esbuild 'build' options object for all global scripts defined in the user provied
  * build options.