@angular-devkit/build-angular 16.0.0-next.7 → 16.0.0-rc.1

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

@@ -0,0 +1,348 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerPlugin = exports.SourceFileCache = void 0;
+const assert = __importStar(require("node:assert"));
+const node_os_1 = require("node:os");
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const typescript_1 = __importDefault(require("typescript"));
+const environment_options_1 = require("../../../utils/environment-options");
+const javascript_transformer_1 = require("../javascript-transformer");
+const load_result_cache_1 = require("../load-result-cache");
+const profiling_1 = require("../profiling");
+const stylesheets_1 = require("../stylesheets");
+const angular_compilation_1 = require("./angular-compilation");
+const aot_compilation_1 = require("./aot-compilation");
+const jit_compilation_1 = require("./jit-compilation");
+const jit_plugin_callbacks_1 = require("./jit-plugin-callbacks");
+/**
+ * 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 info The TypeScript diagnostic relative information to convert.
+ * @returns An esbuild diagnostic message as a PartialMessage object
+ */
+function convertTypeScriptDiagnosticInfo(info, textPrefix) {
+    const newLine = (0, node_os_1.platform)() === 'win32' ? '\r\n' : '\n';
+    let text = typescript_1.default.flattenDiagnosticMessageText(info.messageText, newLine);
+    if (textPrefix) {
+        text = textPrefix + text;
+    }
+    const note = { text };
+    if (info.file) {
+        note.location = {
+            file: info.file.fileName,
+            length: info.length,
+        };
+        // Calculate the line/column location and extract the full line text that has the diagnostic
+        if (info.start) {
+            const { line, character } = typescript_1.default.getLineAndCharacterOfPosition(info.file, info.start);
+            note.location.line = line + 1;
+            note.location.column = character;
+            // The start position for the slice is the first character of the error line
+            const lineStartPosition = typescript_1.default.getPositionOfLineAndCharacter(info.file, line, 0);
+            // The end position for the slice is the first character of the next line or the length of
+            // the entire file if the line is the last line of the file (getPositionOfLineAndCharacter
+            // will error if a nonexistent line is passed).
+            const { line: lastLineOfFile } = typescript_1.default.getLineAndCharacterOfPosition(info.file, info.file.text.length - 1);
+            const lineEndPosition = line < lastLineOfFile
+                ? typescript_1.default.getPositionOfLineAndCharacter(info.file, line + 1, 0)
+                : info.file.text.length;
+            note.location.lineText = info.file.text.slice(lineStartPosition, lineEndPosition).trimEnd();
+        }
+    }
+    return note;
+}
+/**
+ * Converts a TypeScript Diagnostic message into an esbuild compatible message object.
+ * @param diagnostic The TypeScript diagnostic to convert.
+ * @returns An esbuild diagnostic message as a PartialMessage object
+ */
+function convertTypeScriptDiagnostic(diagnostic) {
+    let codePrefix = 'TS';
+    let code = `${diagnostic.code}`;
+    if (diagnostic.source === 'ngtsc') {
+        codePrefix = 'NG';
+        // Remove `-99` Angular prefix from diagnostic code
+        code = code.slice(3);
+    }
+    const message = {
+        ...convertTypeScriptDiagnosticInfo(diagnostic, `${codePrefix}${code}: `),
+        // Store original diagnostic for reference if needed downstream
+        detail: diagnostic,
+    };
+    if (diagnostic.relatedInformation?.length) {
+        message.notes = diagnostic.relatedInformation.map((info) => convertTypeScriptDiagnosticInfo(info));
+    }
+    return message;
+}
+const USING_WINDOWS = (0, node_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();
+        this.typeScriptFileCache = new Map();
+        this.loadResultCache = new load_result_cache_1.MemoryLoadResultCache();
+    }
+    invalidate(files) {
+        this.modifiedFiles.clear();
+        for (let file of files) {
+            this.babelFileCache.delete(file);
+            this.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(file).href);
+            this.loadResultCache.invalidate(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;
+// eslint-disable-next-line max-lines-per-function
+function createCompilerPlugin(pluginOptions, styleOptions) {
+    return {
+        name: 'angular-compiler',
+        // eslint-disable-next-line max-lines-per-function
+        async setup(build) {
+            var _a;
+            let setupWarnings = [];
+            // Initialize a worker pool for JavaScript transformations
+            const javascriptTransformer = new javascript_transformer_1.JavaScriptTransformer(pluginOptions, environment_options_1.maxWorkers);
+            // Setup defines based on the values provided by the Angular compiler-cli
+            const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT } = await angular_compilation_1.AngularCompilation.loadCompilerCli();
+            (_a = build.initialOptions).define ?? (_a.define = {});
+            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;
+                }
+                if (key === 'ngDevMode') {
+                    // ngDevMode is already set based on the builder's script optimization option
+                    continue;
+                }
+                // esbuild requires values to be a string (actual strings need to be quoted).
+                // In this case, all provided values are booleans.
+                build.initialOptions.define[key] = value.toString();
+            }
+            // 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 stylesheetMetafiles;
+            // Create new reusable compilation for the appropriate mode based on the `jit` plugin option
+            const compilation = pluginOptions.jit
+                ? new jit_compilation_1.JitCompilation()
+                : new aot_compilation_1.AotCompilation();
+            // Determines if TypeScript should process JavaScript files based on tsconfig `allowJs` option
+            let shouldTsIgnoreJs = true;
+            build.onStart(async () => {
+                const result = {
+                    warnings: setupWarnings,
+                };
+                // Reset debug performance tracking
+                (0, profiling_1.resetCumulativeDurations)();
+                // Reset stylesheet resource output files
+                stylesheetResourceFiles = [];
+                stylesheetMetafiles = [];
+                // Create Angular compiler host options
+                const hostOptions = {
+                    fileReplacements: pluginOptions.fileReplacements,
+                    modifiedFiles: pluginOptions.sourceFileCache?.modifiedFiles,
+                    sourceFileCache: pluginOptions.sourceFileCache,
+                    async transformStylesheet(data, containingFile, stylesheetFile) {
+                        // Stylesheet file only exists for external stylesheets
+                        const filename = stylesheetFile ?? containingFile;
+                        const stylesheetResult = await (0, stylesheets_1.bundleComponentStylesheet)(styleOptions.inlineStyleLanguage, data, filename, !stylesheetFile, styleOptions, pluginOptions.loadResultCache);
+                        const { contents, resourceFiles, errors, warnings } = stylesheetResult;
+                        if (errors) {
+                            (result.errors ?? (result.errors = [])).push(...errors);
+                        }
+                        (result.warnings ?? (result.warnings = [])).push(...warnings);
+                        stylesheetResourceFiles.push(...resourceFiles);
+                        if (stylesheetResult.metafile) {
+                            stylesheetMetafiles.push(stylesheetResult.metafile);
+                        }
+                        return contents;
+                    },
+                };
+                // Initialize the Angular compilation for the current build.
+                // In watch mode, previous build state will be reused.
+                const { affectedFiles, compilerOptions: { allowJs }, } = await compilation.initialize(pluginOptions.tsconfig, hostOptions, (compilerOptions) => {
+                    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;
+                        compilerOptions.useDefineForClassFields ?? (compilerOptions.useDefineForClassFields = false);
+                        // Only add the warning on the initial build
+                        setupWarnings?.push({
+                            text: 'TypeScript compiler options "target" and "useDefineForClassFields" are set to "ES2022" and ' +
+                                '"false" respectively by the Angular CLI.',
+                            location: { file: pluginOptions.tsconfig },
+                            notes: [
+                                {
+                                    text: 'To control ECMA version and features use the Browerslist configuration. ' +
+                                        'For more information, see https://angular.io/guide/build#configuring-browser-compatibility',
+                                },
+                            ],
+                        });
+                    }
+                    return {
+                        ...compilerOptions,
+                        noEmitOnError: false,
+                        inlineSources: pluginOptions.sourcemap,
+                        inlineSourceMap: pluginOptions.sourcemap,
+                        mapRoot: undefined,
+                        sourceRoot: undefined,
+                    };
+                });
+                shouldTsIgnoreJs = !allowJs;
+                // Clear affected files from the cache (if present)
+                if (pluginOptions.sourceFileCache) {
+                    for (const affected of affectedFiles) {
+                        pluginOptions.sourceFileCache.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(affected.fileName).href);
+                    }
+                }
+                (0, profiling_1.profileSync)('NG_DIAGNOSTICS_TOTAL', () => {
+                    for (const diagnostic of compilation.collectDiagnostics()) {
+                        const message = convertTypeScriptDiagnostic(diagnostic);
+                        if (diagnostic.category === typescript_1.default.DiagnosticCategory.Error) {
+                            (result.errors ?? (result.errors = [])).push(message);
+                        }
+                        else {
+                            (result.warnings ?? (result.warnings = [])).push(message);
+                        }
+                    }
+                });
+                fileEmitter = compilation.createFileEmitter();
+                // Reset the setup warnings so that they are only shown during the first build.
+                setupWarnings = undefined;
+                return result;
+            });
+            build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_TS*', async () => {
+                assert.ok(fileEmitter, 'Invalid plugin execution order');
+                const request = pluginOptions.fileReplacements?.[args.path] ?? args.path;
+                // Skip TS load attempt if JS TypeScript compilation not enabled and file is JS
+                if (shouldTsIgnoreJs && /\.[cm]?js$/.test(request)) {
+                    return undefined;
+                }
+                // 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 = pluginOptions.sourceFileCache?.typeScriptFileCache.get((0, node_url_1.pathToFileURL)(request).href);
+                if (contents === undefined) {
+                    const typescriptResult = await fileEmitter(request);
+                    if (!typescriptResult?.content) {
+                        // No TS result indicates the file is not part of the TypeScript program.
+                        // If allowJs is enabled and the file is JS then defer to the next load hook.
+                        if (!shouldTsIgnoreJs && /\.[cm]?js$/.test(request)) {
+                            return undefined;
+                        }
+                        // Otherwise return an error
+                        return {
+                            errors: [
+                                createMissingFileError(request, args.path, build.initialOptions.absWorkingDir ?? ''),
+                            ],
+                        };
+                    }
+                    contents = await javascriptTransformer.transformData(request, typescriptResult.content, true /* skipLinker */);
+                    pluginOptions.sourceFileCache?.typeScriptFileCache.set((0, node_url_1.pathToFileURL)(request).href, contents);
+                }
+                return {
+                    contents,
+                    loader: 'js',
+                };
+            }, true));
+            build.onLoad({ filter: /\.[cm]?js$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_JS*', async () => {
+                // 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 = pluginOptions.sourceFileCache?.babelFileCache.get(args.path);
+                if (contents === undefined) {
+                    contents = await javascriptTransformer.transformFile(args.path, pluginOptions.jit);
+                    pluginOptions.sourceFileCache?.babelFileCache.set(args.path, contents);
+                }
+                return {
+                    contents,
+                    loader: 'js',
+                };
+            }, true));
+            // Setup bundling of component templates and stylesheets when in JIT mode
+            if (pluginOptions.jit) {
+                (0, jit_plugin_callbacks_1.setupJitPluginCallbacks)(build, styleOptions, stylesheetResourceFiles, pluginOptions.loadResultCache);
+            }
+            build.onEnd((result) => {
+                // Add any component stylesheet resource files to the output files
+                if (stylesheetResourceFiles.length) {
+                    result.outputFiles?.push(...stylesheetResourceFiles);
+                }
+                // Combine component stylesheet metafiles with main metafile
+                if (result.metafile && stylesheetMetafiles.length) {
+                    for (const metafile of stylesheetMetafiles) {
+                        result.metafile.inputs = { ...result.metafile.inputs, ...metafile.inputs };
+                        result.metafile.outputs = { ...result.metafile.outputs, ...metafile.outputs };
+                    }
+                }
+                (0, profiling_1.logCumulativeDurations)();
+            });
+        },
+    };
+}
+exports.createCompilerPlugin = createCompilerPlugin;
+function createMissingFileError(request, original, root) {
+    const error = {
+        text: `File '${path.relative(root, request)}' is missing from the TypeScript compilation.`,
+        notes: [
+            {
+                text: `Ensure the file is part of the TypeScript program via the 'files' or 'include' property.`,
+            },
+        ],
+    };
+    if (request !== original) {
+        error.notes.push({
+            text: `File is requested from a file replacement of '${path.relative(root, original)}'.`,
+        });
+    }
+    return error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/compiler-plugin.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 {\n  Metafile,\n  OnStartResult,\n  OutputFile,\n  PartialMessage,\n  PartialNote,\n  Plugin,\n  PluginBuild,\n} from 'esbuild';\nimport * as assert from 'node:assert';\nimport { platform } from 'node:os';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport ts from 'typescript';\nimport { maxWorkers } from '../../../utils/environment-options';\nimport { JavaScriptTransformer } from '../javascript-transformer';\nimport { LoadResultCache, MemoryLoadResultCache } from '../load-result-cache';\nimport {\n  logCumulativeDurations,\n  profileAsync,\n  profileSync,\n  resetCumulativeDurations,\n} from '../profiling';\nimport { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets';\nimport { AngularCompilation, FileEmitter } from './angular-compilation';\nimport { AngularHostOptions } from './angular-host';\nimport { AotCompilation } from './aot-compilation';\nimport { JitCompilation } from './jit-compilation';\nimport { setupJitPluginCallbacks } from './jit-plugin-callbacks';\n\n/**\n * Converts TypeScript Diagnostic related information into an esbuild compatible note object.\n * Related information is a subset of a full TypeScript Diagnostic and also used for diagnostic\n * notes associated with the main Diagnostic.\n * @param info The TypeScript diagnostic relative information to convert.\n * @returns An esbuild diagnostic message as a PartialMessage object\n */\nfunction convertTypeScriptDiagnosticInfo(\n  info: ts.DiagnosticRelatedInformation,\n  textPrefix?: string,\n): PartialNote {\n  const newLine = platform() === 'win32' ? '\\r\\n' : '\\n';\n  let text = ts.flattenDiagnosticMessageText(info.messageText, newLine);\n  if (textPrefix) {\n    text = textPrefix + text;\n  }\n\n  const note: PartialNote = { text };\n\n  if (info.file) {\n    note.location = {\n      file: info.file.fileName,\n      length: info.length,\n    };\n\n    // Calculate the line/column location and extract the full line text that has the diagnostic\n    if (info.start) {\n      const { line, character } = ts.getLineAndCharacterOfPosition(info.file, info.start);\n      note.location.line = line + 1;\n      note.location.column = character;\n\n      // The start position for the slice is the first character of the error line\n      const lineStartPosition = ts.getPositionOfLineAndCharacter(info.file, line, 0);\n\n      // The end position for the slice is the first character of the next line or the length of\n      // the entire file if the line is the last line of the file (getPositionOfLineAndCharacter\n      // will error if a nonexistent line is passed).\n      const { line: lastLineOfFile } = ts.getLineAndCharacterOfPosition(\n        info.file,\n        info.file.text.length - 1,\n      );\n      const lineEndPosition =\n        line < lastLineOfFile\n          ? ts.getPositionOfLineAndCharacter(info.file, line + 1, 0)\n          : info.file.text.length;\n\n      note.location.lineText = info.file.text.slice(lineStartPosition, lineEndPosition).trimEnd();\n    }\n  }\n\n  return note;\n}\n\n/**\n * Converts a TypeScript Diagnostic message into an esbuild compatible message object.\n * @param diagnostic The TypeScript diagnostic to convert.\n * @returns An esbuild diagnostic message as a PartialMessage object\n */\nfunction convertTypeScriptDiagnostic(diagnostic: ts.Diagnostic): PartialMessage {\n  let codePrefix = 'TS';\n  let code = `${diagnostic.code}`;\n  if (diagnostic.source === 'ngtsc') {\n    codePrefix = 'NG';\n    // Remove `-99` Angular prefix from diagnostic code\n    code = code.slice(3);\n  }\n\n  const message: PartialMessage = {\n    ...convertTypeScriptDiagnosticInfo(diagnostic, `${codePrefix}${code}: `),\n    // Store original diagnostic for reference if needed downstream\n    detail: diagnostic,\n  };\n\n  if (diagnostic.relatedInformation?.length) {\n    message.notes = diagnostic.relatedInformation.map((info) =>\n      convertTypeScriptDiagnosticInfo(info),\n    );\n  }\n\n  return message;\n}\n\nconst USING_WINDOWS = platform() === 'win32';\nconst WINDOWS_SEP_REGEXP = new RegExp(`\\\\${path.win32.sep}`, 'g');\n\nexport class SourceFileCache extends Map<string, ts.SourceFile> {\n  readonly modifiedFiles = new Set<string>();\n  readonly babelFileCache = new Map<string, Uint8Array>();\n  readonly typeScriptFileCache = new Map<string, Uint8Array>();\n  readonly loadResultCache = new MemoryLoadResultCache();\n\n  invalidate(files: Iterable<string>): void {\n    this.modifiedFiles.clear();\n    for (let file of files) {\n      this.babelFileCache.delete(file);\n      this.typeScriptFileCache.delete(pathToFileURL(file).href);\n      this.loadResultCache.invalidate(file);\n\n      // Normalize separators to allow matching TypeScript Host paths\n      if (USING_WINDOWS) {\n        file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);\n      }\n\n      this.delete(file);\n      this.modifiedFiles.add(file);\n    }\n  }\n}\n\nexport interface CompilerPluginOptions {\n  sourcemap: boolean;\n  tsconfig: string;\n  jit?: boolean;\n  advancedOptimizations?: boolean;\n  thirdPartySourcemaps?: boolean;\n  fileReplacements?: Record<string, string>;\n  sourceFileCache?: SourceFileCache;\n  loadResultCache?: LoadResultCache;\n}\n\n// eslint-disable-next-line max-lines-per-function\nexport function createCompilerPlugin(\n  pluginOptions: CompilerPluginOptions,\n  styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },\n): Plugin {\n  return {\n    name: 'angular-compiler',\n    // eslint-disable-next-line max-lines-per-function\n    async setup(build: PluginBuild): Promise<void> {\n      let setupWarnings: PartialMessage[] | undefined = [];\n\n      // Initialize a worker pool for JavaScript transformations\n      const javascriptTransformer = new JavaScriptTransformer(pluginOptions, maxWorkers);\n\n      // Setup defines based on the values provided by the Angular compiler-cli\n      const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT } = await AngularCompilation.loadCompilerCli();\n      build.initialOptions.define ??= {};\n      for (const [key, value] of Object.entries(GLOBAL_DEFS_FOR_TERSER_WITH_AOT)) {\n        if (key in build.initialOptions.define) {\n          // Skip keys that have been manually provided\n          continue;\n        }\n        if (key === 'ngDevMode') {\n          // ngDevMode is already set based on the builder's script optimization option\n          continue;\n        }\n        // esbuild requires values to be a string (actual strings need to be quoted).\n        // In this case, all provided values are booleans.\n        build.initialOptions.define[key] = value.toString();\n      }\n\n      // The file emitter created during `onStart` that will be used during the build in `onLoad` callbacks for TS files\n      let fileEmitter: FileEmitter | undefined;\n\n      // The stylesheet resources from component stylesheets that will be added to the build results output files\n      let stylesheetResourceFiles: OutputFile[] = [];\n      let stylesheetMetafiles: Metafile[];\n\n      // Create new reusable compilation for the appropriate mode based on the `jit` plugin option\n      const compilation: AngularCompilation = pluginOptions.jit\n        ? new JitCompilation()\n        : new AotCompilation();\n\n      // Determines if TypeScript should process JavaScript files based on tsconfig `allowJs` option\n      let shouldTsIgnoreJs = true;\n\n      build.onStart(async () => {\n        const result: OnStartResult = {\n          warnings: setupWarnings,\n        };\n\n        // Reset debug performance tracking\n        resetCumulativeDurations();\n\n        // Reset stylesheet resource output files\n        stylesheetResourceFiles = [];\n        stylesheetMetafiles = [];\n\n        // Create Angular compiler host options\n        const hostOptions: AngularHostOptions = {\n          fileReplacements: pluginOptions.fileReplacements,\n          modifiedFiles: pluginOptions.sourceFileCache?.modifiedFiles,\n          sourceFileCache: pluginOptions.sourceFileCache,\n          async transformStylesheet(data, containingFile, stylesheetFile) {\n            // Stylesheet file only exists for external stylesheets\n            const filename = stylesheetFile ?? containingFile;\n\n            const stylesheetResult = await bundleComponentStylesheet(\n              styleOptions.inlineStyleLanguage,\n              data,\n              filename,\n              !stylesheetFile,\n              styleOptions,\n              pluginOptions.loadResultCache,\n            );\n\n            const { contents, resourceFiles, errors, warnings } = stylesheetResult;\n            if (errors) {\n              (result.errors ??= []).push(...errors);\n            }\n            (result.warnings ??= []).push(...warnings);\n            stylesheetResourceFiles.push(...resourceFiles);\n            if (stylesheetResult.metafile) {\n              stylesheetMetafiles.push(stylesheetResult.metafile);\n            }\n\n            return contents;\n          },\n        };\n\n        // Initialize the Angular compilation for the current build.\n        // In watch mode, previous build state will be reused.\n        const {\n          affectedFiles,\n          compilerOptions: { allowJs },\n        } = await compilation.initialize(pluginOptions.tsconfig, hostOptions, (compilerOptions) => {\n          if (\n            compilerOptions.target === undefined ||\n            compilerOptions.target < ts.ScriptTarget.ES2022\n          ) {\n            // If 'useDefineForClassFields' is already defined in the users project leave the value as is.\n            // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995\n            // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well.\n            compilerOptions.target = ts.ScriptTarget.ES2022;\n            compilerOptions.useDefineForClassFields ??= false;\n\n            // Only add the warning on the initial build\n            setupWarnings?.push({\n              text:\n                'TypeScript compiler options \"target\" and \"useDefineForClassFields\" are set to \"ES2022\" and ' +\n                '\"false\" respectively by the Angular CLI.',\n              location: { file: pluginOptions.tsconfig },\n              notes: [\n                {\n                  text:\n                    'To control ECMA version and features use the Browerslist configuration. ' +\n                    'For more information, see https://angular.io/guide/build#configuring-browser-compatibility',\n                },\n              ],\n            });\n          }\n\n          return {\n            ...compilerOptions,\n            noEmitOnError: false,\n            inlineSources: pluginOptions.sourcemap,\n            inlineSourceMap: pluginOptions.sourcemap,\n            mapRoot: undefined,\n            sourceRoot: undefined,\n          };\n        });\n        shouldTsIgnoreJs = !allowJs;\n\n        // Clear affected files from the cache (if present)\n        if (pluginOptions.sourceFileCache) {\n          for (const affected of affectedFiles) {\n            pluginOptions.sourceFileCache.typeScriptFileCache.delete(\n              pathToFileURL(affected.fileName).href,\n            );\n          }\n        }\n\n        profileSync('NG_DIAGNOSTICS_TOTAL', () => {\n          for (const diagnostic of compilation.collectDiagnostics()) {\n            const message = convertTypeScriptDiagnostic(diagnostic);\n            if (diagnostic.category === ts.DiagnosticCategory.Error) {\n              (result.errors ??= []).push(message);\n            } else {\n              (result.warnings ??= []).push(message);\n            }\n          }\n        });\n\n        fileEmitter = compilation.createFileEmitter();\n\n        // Reset the setup warnings so that they are only shown during the first build.\n        setupWarnings = undefined;\n\n        return result;\n      });\n\n      build.onLoad({ filter: /\\.[cm]?[jt]sx?$/ }, (args) =>\n        profileAsync(\n          'NG_EMIT_TS*',\n          async () => {\n            assert.ok(fileEmitter, 'Invalid plugin execution order');\n\n            const request = pluginOptions.fileReplacements?.[args.path] ?? args.path;\n\n            // Skip TS load attempt if JS TypeScript compilation not enabled and file is JS\n            if (shouldTsIgnoreJs && /\\.[cm]?js$/.test(request)) {\n              return undefined;\n            }\n\n            // The filename is currently used as a cache key. Since the cache is memory only,\n            // the options cannot change and do not need to be represented in the key. If the\n            // cache is later stored to disk, then the options that affect transform output\n            // would need to be added to the key as well as a check for any change of content.\n            let contents = pluginOptions.sourceFileCache?.typeScriptFileCache.get(\n              pathToFileURL(request).href,\n            );\n\n            if (contents === undefined) {\n              const typescriptResult = await fileEmitter(request);\n              if (!typescriptResult?.content) {\n                // No TS result indicates the file is not part of the TypeScript program.\n                // If allowJs is enabled and the file is JS then defer to the next load hook.\n                if (!shouldTsIgnoreJs && /\\.[cm]?js$/.test(request)) {\n                  return undefined;\n                }\n\n                // Otherwise return an error\n                return {\n                  errors: [\n                    createMissingFileError(\n                      request,\n                      args.path,\n                      build.initialOptions.absWorkingDir ?? '',\n                    ),\n                  ],\n                };\n              }\n\n              contents = await javascriptTransformer.transformData(\n                request,\n                typescriptResult.content,\n                true /* skipLinker */,\n              );\n\n              pluginOptions.sourceFileCache?.typeScriptFileCache.set(\n                pathToFileURL(request).href,\n                contents,\n              );\n            }\n\n            return {\n              contents,\n              loader: 'js',\n            };\n          },\n          true,\n        ),\n      );\n\n      build.onLoad({ filter: /\\.[cm]?js$/ }, (args) =>\n        profileAsync(\n          'NG_EMIT_JS*',\n          async () => {\n            // The filename is currently used as a cache key. Since the cache is memory only,\n            // the options cannot change and do not need to be represented in the key. If the\n            // cache is later stored to disk, then the options that affect transform output\n            // would need to be added to the key as well as a check for any change of content.\n            let contents = pluginOptions.sourceFileCache?.babelFileCache.get(args.path);\n            if (contents === undefined) {\n              contents = await javascriptTransformer.transformFile(args.path, pluginOptions.jit);\n              pluginOptions.sourceFileCache?.babelFileCache.set(args.path, contents);\n            }\n\n            return {\n              contents,\n              loader: 'js',\n            };\n          },\n          true,\n        ),\n      );\n\n      // Setup bundling of component templates and stylesheets when in JIT mode\n      if (pluginOptions.jit) {\n        setupJitPluginCallbacks(\n          build,\n          styleOptions,\n          stylesheetResourceFiles,\n          pluginOptions.loadResultCache,\n        );\n      }\n\n      build.onEnd((result) => {\n        // Add any component stylesheet resource files to the output files\n        if (stylesheetResourceFiles.length) {\n          result.outputFiles?.push(...stylesheetResourceFiles);\n        }\n\n        // Combine component stylesheet metafiles with main metafile\n        if (result.metafile && stylesheetMetafiles.length) {\n          for (const metafile of stylesheetMetafiles) {\n            result.metafile.inputs = { ...result.metafile.inputs, ...metafile.inputs };\n            result.metafile.outputs = { ...result.metafile.outputs, ...metafile.outputs };\n          }\n        }\n\n        logCumulativeDurations();\n      });\n    },\n  };\n}\n\nfunction createMissingFileError(request: string, original: string, root: string): PartialMessage {\n  const error = {\n    text: `File '${path.relative(root, request)}' is missing from the TypeScript compilation.`,\n    notes: [\n      {\n        text: `Ensure the file is part of the TypeScript program via the 'files' or 'include' property.`,\n      },\n    ],\n  };\n\n  if (request !== original) {\n    error.notes.push({\n      text: `File is requested from a file replacement of '${path.relative(root, original)}'.`,\n    });\n  }\n\n  return error;\n}\n"]}

package/src/builders/browser-esbuild/angular/jit-compilation.d.ts

@@ -5,18 +5,15 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import type ng from '@angular/compiler-cli';
 import ts from 'typescript';
-import { AngularHostOptions } from '../angular-host';
-export interface EmitFileResult {
-    content?: string;
-    map?: string;
-    dependencies: readonly string[];
-}
-export type FileEmitter = (file: string) => Promise<EmitFileResult | undefined>;
-export declare class JitCompilation {
+import { AngularCompilation, FileEmitter } from './angular-compilation';
+import { AngularHostOptions } from './angular-host';
+export declare class JitCompilation extends AngularCompilation {
     #private;
-    initialize(rootNames: string[], compilerOptions: ts.CompilerOptions, hostOptions: AngularHostOptions, configurationDiagnostics?: ts.Diagnostic[]): Promise<{
+    initialize(tsconfig: string, hostOptions: AngularHostOptions, compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions): Promise<{
         affectedFiles: ReadonlySet<ts.SourceFile>;
+        compilerOptions: ng.CompilerOptions;
     }>;
     collectDiagnostics(): Iterable<ts.Diagnostic>;
     createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter;

package/src/builders/browser-esbuild/angular/jit-compilation.js

@@ -25,9 +25,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JitCompilation = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const typescript_1 = __importDefault(require("typescript"));
-const angular_compilation_1 = require("../angular-compilation");
-const angular_host_1 = require("../angular-host");
 const profiling_1 = require("../profiling");
+const angular_compilation_1 = require("./angular-compilation");
+const angular_host_1 = require("./angular-host");
 const jit_resource_transformer_1 = require("./jit-resource-transformer");
 class JitCompilationState {
     constructor(typeScriptProgram, constructorParametersDownlevelTransform, replaceResourcesTransform) {
@@ -36,20 +36,24 @@ class JitCompilationState {
         this.replaceResourcesTransform = replaceResourcesTransform;
     }
 }
-class JitCompilation {
+class JitCompilation extends angular_compilation_1.AngularCompilation {
     constructor() {
+        super(...arguments);
         _JitCompilation_state.set(this, void 0);
     }
-    async initialize(rootNames, compilerOptions, hostOptions, configurationDiagnostics) {
+    async initialize(tsconfig, hostOptions, compilerOptionsTransformer) {
         // Dynamically load the Angular compiler CLI package
         const { constructorParametersDownlevelTransform } = await angular_compilation_1.AngularCompilation.loadCompilerCli();
+        // Load the compiler configuration and transform as needed
+        const { options: originalCompilerOptions, rootNames, errors: configurationDiagnostics, } = await this.loadConfiguration(tsconfig);
+        const compilerOptions = compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;
         // Create Angular compiler host
         const host = (0, angular_host_1.createAngularCompilerHost)(compilerOptions, hostOptions);
         // Create the TypeScript Program
         const typeScriptProgram = (0, profiling_1.profileSync)('TS_CREATE_PROGRAM', () => typescript_1.default.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, compilerOptions, host, __classPrivateFieldGet(this, _JitCompilation_state, "f")?.typeScriptProgram, configurationDiagnostics));
         const affectedFiles = (0, profiling_1.profileSync)('TS_FIND_AFFECTED', () => findAffectedFiles(typeScriptProgram));
         __classPrivateFieldSet(this, _JitCompilation_state, new JitCompilationState(typeScriptProgram, constructorParametersDownlevelTransform(typeScriptProgram.getProgram()), (0, jit_resource_transformer_1.createJitResourceTransformer)(() => typeScriptProgram.getProgram().getTypeChecker())), "f");
-        return { affectedFiles };
+        return { affectedFiles, compilerOptions };
     }
     *collectDiagnostics() {
         (0, node_assert_1.default)(__classPrivateFieldGet(this, _JitCompilation_state, "f"), 'Compilation must be initialized prior to collecting diagnostics.');
@@ -93,4 +97,4 @@ function findAffectedFiles(builder) {
     }
     return affectedFiles;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-compilation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-compilation.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 assert from 'node:assert';\nimport ts from 'typescript';\nimport { AngularCompilation } from '../angular-compilation';\nimport { AngularHostOptions, createAngularCompilerHost } from '../angular-host';\nimport { profileSync } from '../profiling';\nimport { createJitResourceTransformer } from './jit-resource-transformer';\n\nclass JitCompilationState {\n  constructor(\n    public readonly typeScriptProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n    public readonly constructorParametersDownlevelTransform: ts.TransformerFactory<ts.SourceFile>,\n    public readonly replaceResourcesTransform: ts.TransformerFactory<ts.SourceFile>,\n  ) {}\n}\n\nexport interface EmitFileResult {\n  content?: string;\n  map?: string;\n  dependencies: readonly string[];\n}\nexport type FileEmitter = (file: string) => Promise<EmitFileResult | undefined>;\n\nexport class JitCompilation {\n  #state?: JitCompilationState;\n\n  async initialize(\n    rootNames: string[],\n    compilerOptions: ts.CompilerOptions,\n    hostOptions: AngularHostOptions,\n    configurationDiagnostics?: ts.Diagnostic[],\n  ): Promise<{ affectedFiles: ReadonlySet<ts.SourceFile> }> {\n    // Dynamically load the Angular compiler CLI package\n    const { constructorParametersDownlevelTransform } = await AngularCompilation.loadCompilerCli();\n\n    // Create Angular compiler host\n    const host = createAngularCompilerHost(compilerOptions, hostOptions);\n\n    // Create the TypeScript Program\n    const typeScriptProgram = profileSync('TS_CREATE_PROGRAM', () =>\n      ts.createEmitAndSemanticDiagnosticsBuilderProgram(\n        rootNames,\n        compilerOptions,\n        host,\n        this.#state?.typeScriptProgram,\n        configurationDiagnostics,\n      ),\n    );\n\n    const affectedFiles = profileSync('TS_FIND_AFFECTED', () =>\n      findAffectedFiles(typeScriptProgram),\n    );\n\n    this.#state = new JitCompilationState(\n      typeScriptProgram,\n      constructorParametersDownlevelTransform(typeScriptProgram.getProgram()),\n      createJitResourceTransformer(() => typeScriptProgram.getProgram().getTypeChecker()),\n    );\n\n    return { affectedFiles };\n  }\n\n  *collectDiagnostics(): Iterable<ts.Diagnostic> {\n    assert(this.#state, 'Compilation must be initialized prior to collecting diagnostics.');\n    const { typeScriptProgram } = this.#state;\n\n    // Collect program level diagnostics\n    yield* typeScriptProgram.getConfigFileParsingDiagnostics();\n    yield* typeScriptProgram.getOptionsDiagnostics();\n    yield* typeScriptProgram.getGlobalDiagnostics();\n    yield* profileSync('NG_DIAGNOSTICS_SYNTACTIC', () =>\n      typeScriptProgram.getSyntacticDiagnostics(),\n    );\n    yield* profileSync('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics());\n  }\n\n  createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter {\n    assert(this.#state, 'Compilation must be initialized prior to emitting files.');\n    const {\n      typeScriptProgram,\n      constructorParametersDownlevelTransform,\n      replaceResourcesTransform,\n    } = this.#state;\n\n    const transformers = {\n      before: [replaceResourcesTransform, constructorParametersDownlevelTransform],\n    };\n\n    return async (file: string) => {\n      const sourceFile = typeScriptProgram.getSourceFile(file);\n      if (!sourceFile) {\n        return undefined;\n      }\n\n      let content: string | undefined;\n      typeScriptProgram.emit(\n        sourceFile,\n        (filename, data) => {\n          if (/\\.[cm]?js$/.test(filename)) {\n            content = data;\n          }\n        },\n        undefined /* cancellationToken */,\n        undefined /* emitOnlyDtsFiles */,\n        transformers,\n      );\n\n      onAfterEmit?.(sourceFile);\n\n      return { content, dependencies: [] };\n    };\n  }\n}\n\nfunction findAffectedFiles(\n  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n): Set<ts.SourceFile> {\n  const affectedFiles = new Set<ts.SourceFile>();\n\n  let result;\n  while ((result = builder.getSemanticDiagnosticsOfNextAffectedFile())) {\n    affectedFiles.add(result.affected as ts.SourceFile);\n  }\n\n  return affectedFiles;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-compilation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-compilation.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 ng from '@angular/compiler-cli';\nimport assert from 'node:assert';\nimport ts from 'typescript';\nimport { profileSync } from '../profiling';\nimport { AngularCompilation, FileEmitter } from './angular-compilation';\nimport { AngularHostOptions, createAngularCompilerHost } from './angular-host';\nimport { createJitResourceTransformer } from './jit-resource-transformer';\n\nclass JitCompilationState {\n  constructor(\n    public readonly typeScriptProgram: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n    public readonly constructorParametersDownlevelTransform: ts.TransformerFactory<ts.SourceFile>,\n    public readonly replaceResourcesTransform: ts.TransformerFactory<ts.SourceFile>,\n  ) {}\n}\n\nexport class JitCompilation extends AngularCompilation {\n  #state?: JitCompilationState;\n\n  async initialize(\n    tsconfig: string,\n    hostOptions: AngularHostOptions,\n    compilerOptionsTransformer?: (compilerOptions: ng.CompilerOptions) => ng.CompilerOptions,\n  ): Promise<{ affectedFiles: ReadonlySet<ts.SourceFile>; compilerOptions: ng.CompilerOptions }> {\n    // Dynamically load the Angular compiler CLI package\n    const { constructorParametersDownlevelTransform } = await AngularCompilation.loadCompilerCli();\n\n    // Load the compiler configuration and transform as needed\n    const {\n      options: originalCompilerOptions,\n      rootNames,\n      errors: configurationDiagnostics,\n    } = await this.loadConfiguration(tsconfig);\n    const compilerOptions =\n      compilerOptionsTransformer?.(originalCompilerOptions) ?? originalCompilerOptions;\n\n    // Create Angular compiler host\n    const host = createAngularCompilerHost(compilerOptions, hostOptions);\n\n    // Create the TypeScript Program\n    const typeScriptProgram = profileSync('TS_CREATE_PROGRAM', () =>\n      ts.createEmitAndSemanticDiagnosticsBuilderProgram(\n        rootNames,\n        compilerOptions,\n        host,\n        this.#state?.typeScriptProgram,\n        configurationDiagnostics,\n      ),\n    );\n\n    const affectedFiles = profileSync('TS_FIND_AFFECTED', () =>\n      findAffectedFiles(typeScriptProgram),\n    );\n\n    this.#state = new JitCompilationState(\n      typeScriptProgram,\n      constructorParametersDownlevelTransform(typeScriptProgram.getProgram()),\n      createJitResourceTransformer(() => typeScriptProgram.getProgram().getTypeChecker()),\n    );\n\n    return { affectedFiles, compilerOptions };\n  }\n\n  *collectDiagnostics(): Iterable<ts.Diagnostic> {\n    assert(this.#state, 'Compilation must be initialized prior to collecting diagnostics.');\n    const { typeScriptProgram } = this.#state;\n\n    // Collect program level diagnostics\n    yield* typeScriptProgram.getConfigFileParsingDiagnostics();\n    yield* typeScriptProgram.getOptionsDiagnostics();\n    yield* typeScriptProgram.getGlobalDiagnostics();\n    yield* profileSync('NG_DIAGNOSTICS_SYNTACTIC', () =>\n      typeScriptProgram.getSyntacticDiagnostics(),\n    );\n    yield* profileSync('NG_DIAGNOSTICS_SEMANTIC', () => typeScriptProgram.getSemanticDiagnostics());\n  }\n\n  createFileEmitter(onAfterEmit?: (sourceFile: ts.SourceFile) => void): FileEmitter {\n    assert(this.#state, 'Compilation must be initialized prior to emitting files.');\n    const {\n      typeScriptProgram,\n      constructorParametersDownlevelTransform,\n      replaceResourcesTransform,\n    } = this.#state;\n\n    const transformers = {\n      before: [replaceResourcesTransform, constructorParametersDownlevelTransform],\n    };\n\n    return async (file: string) => {\n      const sourceFile = typeScriptProgram.getSourceFile(file);\n      if (!sourceFile) {\n        return undefined;\n      }\n\n      let content: string | undefined;\n      typeScriptProgram.emit(\n        sourceFile,\n        (filename, data) => {\n          if (/\\.[cm]?js$/.test(filename)) {\n            content = data;\n          }\n        },\n        undefined /* cancellationToken */,\n        undefined /* emitOnlyDtsFiles */,\n        transformers,\n      );\n\n      onAfterEmit?.(sourceFile);\n\n      return { content, dependencies: [] };\n    };\n  }\n}\n\nfunction findAffectedFiles(\n  builder: ts.EmitAndSemanticDiagnosticsBuilderProgram,\n): Set<ts.SourceFile> {\n  const affectedFiles = new Set<ts.SourceFile>();\n\n  let result;\n  while ((result = builder.getSemanticDiagnosticsOfNextAffectedFile())) {\n    affectedFiles.add(result.affected as ts.SourceFile);\n  }\n\n  return affectedFiles;\n}\n"]}

package/src/builders/browser-esbuild/angular/jit-plugin-callbacks.d.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import type { OutputFile, PluginBuild } from 'esbuild';
+import { LoadResultCache } from '../load-result-cache';
 import { BundleStylesheetOptions } from '../stylesheets';
 /**
  * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing
@@ -18,4 +19,4 @@ import { BundleStylesheetOptions } from '../stylesheets';
  */
 export declare function setupJitPluginCallbacks(build: PluginBuild, styleOptions: BundleStylesheetOptions & {
     inlineStyleLanguage: string;
-}, stylesheetResourceFiles: OutputFile[]): void;
+}, stylesheetResourceFiles: OutputFile[], cache?: LoadResultCache): void;

package/src/builders/browser-esbuild/angular/jit-plugin-callbacks.js

@@ -54,7 +54,7 @@ async function loadEntry(entry, root, skipRead) {
  * @param styleOptions The options to use when bundling stylesheets.
  * @param stylesheetResourceFiles An array where stylesheet resources will be added.
  */
-function setupJitPluginCallbacks(build, styleOptions, stylesheetResourceFiles) {
+function setupJitPluginCallbacks(build, styleOptions, stylesheetResourceFiles, cache) {
     const root = build.initialOptions.absWorkingDir ?? '';
     // Add a resolve callback to capture and parse any JIT URIs that were added by the
     // JIT resource TypeScript transformer.
@@ -89,7 +89,7 @@ function setupJitPluginCallbacks(build, styleOptions, stylesheetResourceFiles) {
         const entry = await loadEntry(args.path, root, true /* skipRead */);
         const { contents, resourceFiles, errors, warnings } = await (0, stylesheets_1.bundleComponentStylesheet)(styleOptions.inlineStyleLanguage, 
         // The `data` parameter is only needed for a stylesheet if it was inline
-        entry.contents ?? '', entry.path, entry.contents !== undefined, styleOptions);
+        entry.contents ?? '', entry.path, entry.contents !== undefined, styleOptions, cache);
         stylesheetResourceFiles.push(...resourceFiles);
         return {
             errors,
@@ -110,4 +110,4 @@ function setupJitPluginCallbacks(build, styleOptions, stylesheetResourceFiles) {
     });
 }
 exports.setupJitPluginCallbacks = setupJitPluginCallbacks;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-plugin-callbacks.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.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 { OutputFile, PluginBuild } from 'esbuild';\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets';\nimport {\n  JIT_NAMESPACE_REGEXP,\n  JIT_STYLE_NAMESPACE,\n  JIT_TEMPLATE_NAMESPACE,\n  parseJitUri,\n} from './uri';\n\n/**\n * Loads/extracts the contents from a load callback Angular JIT entry.\n * An Angular JIT entry represents either a file path for a component resource or base64\n * encoded data for an inline component resource.\n * @param entry The value that represents content to load.\n * @param root The absolute path for the root of the build (typically the workspace root).\n * @param skipRead If true, do not attempt to read the file; if false, read file content from disk.\n * This option has no effect if the entry does not originate from a file. Defaults to false.\n * @returns An object containing the absolute path of the contents and optionally the actual contents.\n * For inline entries the contents will always be provided.\n */\nasync function loadEntry(\n  entry: string,\n  root: string,\n  skipRead?: boolean,\n): Promise<{ path: string; contents?: string }> {\n  if (entry.startsWith('file:')) {\n    const specifier = path.join(root, entry.slice(5));\n\n    return {\n      path: specifier,\n      contents: skipRead ? undefined : await readFile(specifier, 'utf-8'),\n    };\n  } else if (entry.startsWith('inline:')) {\n    const [importer, data] = entry.slice(7).split(';', 2);\n\n    return {\n      path: path.join(root, importer),\n      contents: Buffer.from(data, 'base64').toString(),\n    };\n  } else {\n    throw new Error('Invalid data for Angular JIT entry.');\n  }\n}\n\n/**\n * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing\n * for both Component stylesheets and templates. These callbacks work alongside the JIT\n * resource TypeScript transformer to convert and then bundle Component resources as\n * static imports.\n * @param build An esbuild {@link PluginBuild} instance used to add callbacks.\n * @param styleOptions The options to use when bundling stylesheets.\n * @param stylesheetResourceFiles An array where stylesheet resources will be added.\n */\nexport function setupJitPluginCallbacks(\n  build: PluginBuild,\n  styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },\n  stylesheetResourceFiles: OutputFile[],\n): void {\n  const root = build.initialOptions.absWorkingDir ?? '';\n\n  // Add a resolve callback to capture and parse any JIT URIs that were added by the\n  // JIT resource TypeScript transformer.\n  // Resources originating from a file are resolved as relative from the containing file (importer).\n  build.onResolve({ filter: JIT_NAMESPACE_REGEXP }, (args) => {\n    const parsed = parseJitUri(args.path);\n    if (!parsed) {\n      return undefined;\n    }\n\n    const { namespace, origin, specifier } = parsed;\n\n    if (origin === 'file') {\n      return {\n        // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file).\n        // This is only necessary for custom namespaces. esbuild will handle the file namespace.\n        path: 'file:' + path.relative(root, path.join(path.dirname(args.importer), specifier)),\n        namespace,\n      };\n    } else {\n      // Inline data may need the importer to resolve imports/references within the content\n      const importer = path.relative(root, args.importer);\n\n      return {\n        path: `inline:${importer};${specifier}`,\n        namespace,\n      };\n    }\n  });\n\n  // Add a load callback to handle Component stylesheets (both inline and external)\n  build.onLoad({ filter: /./, namespace: JIT_STYLE_NAMESPACE }, async (args) => {\n    // skipRead is used here because the stylesheet bundling will read a file stylesheet\n    // directly either via a preprocessor or esbuild itself.\n    const entry = await loadEntry(args.path, root, true /* skipRead */);\n\n    const { contents, resourceFiles, errors, warnings } = await bundleComponentStylesheet(\n      styleOptions.inlineStyleLanguage,\n      // The `data` parameter is only needed for a stylesheet if it was inline\n      entry.contents ?? '',\n      entry.path,\n      entry.contents !== undefined,\n      styleOptions,\n    );\n\n    stylesheetResourceFiles.push(...resourceFiles);\n\n    return {\n      errors,\n      warnings,\n      contents,\n      loader: 'text',\n    };\n  });\n\n  // Add a load callback to handle Component templates\n  // NOTE: While this callback supports both inline and external templates, the transformer\n  // currently only supports generating URIs for external templates.\n  build.onLoad({ filter: /./, namespace: JIT_TEMPLATE_NAMESPACE }, async (args) => {\n    const { contents } = await loadEntry(args.path, root);\n\n    return {\n      contents,\n      loader: 'text',\n    };\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jit-plugin-callbacks.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/angular/jit-plugin-callbacks.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;;;AAGH,+CAA4C;AAC5C,0DAA6B;AAE7B,gDAAoF;AACpF,+BAKe;AAEf;;;;;;;;;;GAUG;AACH,KAAK,UAAU,SAAS,CACtB,KAAa,EACb,IAAY,EACZ,QAAkB;IAElB,IAAI,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE;QAC7B,MAAM,SAAS,GAAG,mBAAI,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAElD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,IAAA,mBAAQ,EAAC,SAAS,EAAE,OAAO,CAAC;SACpE,CAAC;KACH;SAAM,IAAI,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;QACtC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAEtD,OAAO;YACL,IAAI,EAAE,mBAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC;YAC/B,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,QAAQ,EAAE;SACjD,CAAC;KACH;SAAM;QACL,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;KACxD;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,uBAAuB,CACrC,KAAkB,EAClB,YAAuE,EACvE,uBAAqC,EACrC,KAAuB;IAEvB,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC,aAAa,IAAI,EAAE,CAAC;IAEtD,kFAAkF;IAClF,uCAAuC;IACvC,kGAAkG;IAClG,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,0BAAoB,EAAE,EAAE,CAAC,IAAI,EAAE,EAAE;QACzD,MAAM,MAAM,GAAG,IAAA,iBAAW,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE;YACX,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QAEhD,IAAI,MAAM,KAAK,MAAM,EAAE;YACrB,OAAO;gBACL,yFAAyF;gBACzF,wFAAwF;gBACxF,IAAI,EAAE,OAAO,GAAG,mBAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,mBAAI,CAAC,IAAI,CAAC,mBAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;gBACtF,SAAS;aACV,CAAC;SACH;aAAM;YACL,qFAAqF;YACrF,MAAM,QAAQ,GAAG,mBAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEpD,OAAO;gBACL,IAAI,EAAE,UAAU,QAAQ,IAAI,SAAS,EAAE;gBACvC,SAAS;aACV,CAAC;SACH;IACH,CAAC,CAAC,CAAC;IAEH,iFAAiF;IACjF,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,yBAAmB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC3E,oFAAoF;QACpF,wDAAwD;QACxD,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAEpE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAA,uCAAyB,EACnF,YAAY,CAAC,mBAAmB;QAChC,wEAAwE;QACxE,KAAK,CAAC,QAAQ,IAAI,EAAE,EACpB,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,QAAQ,KAAK,SAAS,EAC5B,YAAY,EACZ,KAAK,CACN,CAAC;QAEF,uBAAuB,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,CAAC;QAE/C,OAAO;YACL,MAAM;YACN,QAAQ;YACR,QAAQ;YACR,MAAM,EAAE,MAAM;SACf,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,oDAAoD;IACpD,yFAAyF;IACzF,kEAAkE;IAClE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,4BAAsB,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAC9E,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAEtD,OAAO;YACL,QAAQ;YACR,MAAM,EAAE,MAAM;SACf,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AA1ED,0DA0EC","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 { OutputFile, PluginBuild } from 'esbuild';\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { LoadResultCache } from '../load-result-cache';\nimport { BundleStylesheetOptions, bundleComponentStylesheet } from '../stylesheets';\nimport {\n  JIT_NAMESPACE_REGEXP,\n  JIT_STYLE_NAMESPACE,\n  JIT_TEMPLATE_NAMESPACE,\n  parseJitUri,\n} from './uri';\n\n/**\n * Loads/extracts the contents from a load callback Angular JIT entry.\n * An Angular JIT entry represents either a file path for a component resource or base64\n * encoded data for an inline component resource.\n * @param entry The value that represents content to load.\n * @param root The absolute path for the root of the build (typically the workspace root).\n * @param skipRead If true, do not attempt to read the file; if false, read file content from disk.\n * This option has no effect if the entry does not originate from a file. Defaults to false.\n * @returns An object containing the absolute path of the contents and optionally the actual contents.\n * For inline entries the contents will always be provided.\n */\nasync function loadEntry(\n  entry: string,\n  root: string,\n  skipRead?: boolean,\n): Promise<{ path: string; contents?: string }> {\n  if (entry.startsWith('file:')) {\n    const specifier = path.join(root, entry.slice(5));\n\n    return {\n      path: specifier,\n      contents: skipRead ? undefined : await readFile(specifier, 'utf-8'),\n    };\n  } else if (entry.startsWith('inline:')) {\n    const [importer, data] = entry.slice(7).split(';', 2);\n\n    return {\n      path: path.join(root, importer),\n      contents: Buffer.from(data, 'base64').toString(),\n    };\n  } else {\n    throw new Error('Invalid data for Angular JIT entry.');\n  }\n}\n\n/**\n * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing\n * for both Component stylesheets and templates. These callbacks work alongside the JIT\n * resource TypeScript transformer to convert and then bundle Component resources as\n * static imports.\n * @param build An esbuild {@link PluginBuild} instance used to add callbacks.\n * @param styleOptions The options to use when bundling stylesheets.\n * @param stylesheetResourceFiles An array where stylesheet resources will be added.\n */\nexport function setupJitPluginCallbacks(\n  build: PluginBuild,\n  styleOptions: BundleStylesheetOptions & { inlineStyleLanguage: string },\n  stylesheetResourceFiles: OutputFile[],\n  cache?: LoadResultCache,\n): void {\n  const root = build.initialOptions.absWorkingDir ?? '';\n\n  // Add a resolve callback to capture and parse any JIT URIs that were added by the\n  // JIT resource TypeScript transformer.\n  // Resources originating from a file are resolved as relative from the containing file (importer).\n  build.onResolve({ filter: JIT_NAMESPACE_REGEXP }, (args) => {\n    const parsed = parseJitUri(args.path);\n    if (!parsed) {\n      return undefined;\n    }\n\n    const { namespace, origin, specifier } = parsed;\n\n    if (origin === 'file') {\n      return {\n        // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file).\n        // This is only necessary for custom namespaces. esbuild will handle the file namespace.\n        path: 'file:' + path.relative(root, path.join(path.dirname(args.importer), specifier)),\n        namespace,\n      };\n    } else {\n      // Inline data may need the importer to resolve imports/references within the content\n      const importer = path.relative(root, args.importer);\n\n      return {\n        path: `inline:${importer};${specifier}`,\n        namespace,\n      };\n    }\n  });\n\n  // Add a load callback to handle Component stylesheets (both inline and external)\n  build.onLoad({ filter: /./, namespace: JIT_STYLE_NAMESPACE }, async (args) => {\n    // skipRead is used here because the stylesheet bundling will read a file stylesheet\n    // directly either via a preprocessor or esbuild itself.\n    const entry = await loadEntry(args.path, root, true /* skipRead */);\n\n    const { contents, resourceFiles, errors, warnings } = await bundleComponentStylesheet(\n      styleOptions.inlineStyleLanguage,\n      // The `data` parameter is only needed for a stylesheet if it was inline\n      entry.contents ?? '',\n      entry.path,\n      entry.contents !== undefined,\n      styleOptions,\n      cache,\n    );\n\n    stylesheetResourceFiles.push(...resourceFiles);\n\n    return {\n      errors,\n      warnings,\n      contents,\n      loader: 'text',\n    };\n  });\n\n  // Add a load callback to handle Component templates\n  // NOTE: While this callback supports both inline and external templates, the transformer\n  // currently only supports generating URIs for external templates.\n  build.onLoad({ filter: /./, namespace: JIT_TEMPLATE_NAMESPACE }, async (args) => {\n    const { contents } = await loadEntry(args.path, root);\n\n    return {\n      contents,\n      loader: 'text',\n    };\n  });\n}\n"]}