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

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

@@ -0,0 +1,350 @@
+"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 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();
+    }
+    invalidate(files) {
+        this.modifiedFiles.clear();
+        for (let file of files) {
+            this.babelFileCache.delete(file);
+            this.typeScriptFileCache.delete((0, node_url_1.pathToFileURL)(file).href);
+            // 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);
+            const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT, readConfiguration } = await angular_compilation_1.AngularCompilation.loadCompilerCli();
+            // Setup defines based on the values provided by the Angular compiler-cli
+            (_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 tsconfig is loaded in setup instead of in start to allow the esbuild target build option to be modified.
+            // esbuild build options can only be modified in setup prior to starting the build.
+            const { options: compilerOptions, rootNames, errors: configurationDiagnostics, } = (0, profiling_1.profileSync)('NG_READ_CONFIG', () => readConfiguration(pluginOptions.tsconfig, {
+                noEmitOnError: false,
+                suppressOutputPathCheck: true,
+                outDir: undefined,
+                inlineSources: pluginOptions.sourcemap,
+                inlineSourceMap: pluginOptions.sourcemap,
+                sourceMap: false,
+                mapRoot: undefined,
+                sourceRoot: undefined,
+                declaration: false,
+                declarationMap: false,
+                allowEmptyCodegenFiles: false,
+                annotationsAs: 'decorators',
+                enableResourceInlining: false,
+            }));
+            if (compilerOptions.target === undefined || compilerOptions.target < typescript_1.default.ScriptTarget.ES2022) {
+                // If 'useDefineForClassFields' is already defined in the users project leave the value as is.
+                // Otherwise fallback to false due to https://github.com/microsoft/TypeScript/issues/45995
+                // which breaks the deprecated `@Effects` NGRX decorator and potentially other existing code as well.
+                compilerOptions.target = typescript_1.default.ScriptTarget.ES2022;
+                compilerOptions.useDefineForClassFields ?? (compilerOptions.useDefineForClassFields = false);
+                (setupWarnings ?? (setupWarnings = [])).push({
+                    text: 'TypeScript compiler options "target" and "useDefineForClassFields" are set to "ES2022" and ' +
+                        '"false" respectively by the Angular CLI.\n' +
+                        `NOTE: You can set the "target" to "ES2022" in the project's tsconfig to remove this warning.`,
+                    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',
+                        },
+                    ],
+                });
+            }
+            // 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;
+            let compilation;
+            build.onStart(async () => {
+                const result = {
+                    warnings: setupWarnings,
+                };
+                // Reset the setup warnings so that they are only shown during the first build.
+                setupWarnings = undefined;
+                // Reset debug performance tracking
+                (0, profiling_1.resetCumulativeDurations)();
+                // Reset stylesheet resource output files
+                stylesheetResourceFiles = [];
+                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);
+                        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;
+                    },
+                };
+                // Create new compilation if first build; otherwise, use existing for rebuilds
+                if (pluginOptions.jit) {
+                    compilation ?? (compilation = new jit_compilation_1.JitCompilation());
+                }
+                else {
+                    compilation ?? (compilation = new aot_compilation_1.AotCompilation());
+                }
+                // Initialize the Angular compilation for the current build.
+                // In watch mode, previous build state will be reused.
+                const { affectedFiles } = await compilation.initialize(rootNames, compilerOptions, hostOptions, configurationDiagnostics);
+                // 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', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    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();
+                return result;
+            });
+            build.onLoad({ filter: compilerOptions.allowJs ? /\.[cm]?[jt]sx?$/ : /\.[cm]?tsx?$/ }, (args) => (0, profiling_1.profileAsync)('NG_EMIT_TS*', async () => {
+                assert.ok(fileEmitter, 'Invalid plugin execution order');
+                const request = pluginOptions.fileReplacements?.[args.path] ?? args.path;
+                // 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 (compilerOptions.allowJs && /\.[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);
+            }
+            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 {\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\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\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}\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      const { GLOBAL_DEFS_FOR_TERSER_WITH_AOT, readConfiguration } =\n        await AngularCompilation.loadCompilerCli();\n\n      // Setup defines based on the values provided by the Angular compiler-cli\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 tsconfig is loaded in setup instead of in start to allow the esbuild target build option to be modified.\n      // esbuild build options can only be modified in setup prior to starting the build.\n      const {\n        options: compilerOptions,\n        rootNames,\n        errors: configurationDiagnostics,\n      } = profileSync('NG_READ_CONFIG', () =>\n        readConfiguration(pluginOptions.tsconfig, {\n          noEmitOnError: false,\n          suppressOutputPathCheck: true,\n          outDir: undefined,\n          inlineSources: pluginOptions.sourcemap,\n          inlineSourceMap: pluginOptions.sourcemap,\n          sourceMap: false,\n          mapRoot: undefined,\n          sourceRoot: undefined,\n          declaration: false,\n          declarationMap: false,\n          allowEmptyCodegenFiles: false,\n          annotationsAs: 'decorators',\n          enableResourceInlining: false,\n        }),\n      );\n\n      if (compilerOptions.target === undefined || compilerOptions.target < ts.ScriptTarget.ES2022) {\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        (setupWarnings ??= []).push({\n          text:\n            'TypeScript compiler options \"target\" and \"useDefineForClassFields\" are set to \"ES2022\" and ' +\n            '\"false\" respectively by the Angular CLI.\\n' +\n            `NOTE: You can set the \"target\" to \"ES2022\" in the project's tsconfig to remove this warning.`,\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      // 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\n      let stylesheetMetafiles: Metafile[];\n\n      let compilation: AngularCompilation | undefined;\n\n      build.onStart(async () => {\n        const result: OnStartResult = {\n          warnings: setupWarnings,\n        };\n\n        // Reset the setup warnings so that they are only shown during the first build.\n        setupWarnings = undefined;\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            );\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        // Create new compilation if first build; otherwise, use existing for rebuilds\n        if (pluginOptions.jit) {\n          compilation ??= new JitCompilation();\n        } else {\n          compilation ??= new AotCompilation();\n        }\n\n        // Initialize the Angular compilation for the current build.\n        // In watch mode, previous build state will be reused.\n        const { affectedFiles } = await compilation.initialize(\n          rootNames,\n          compilerOptions,\n          hostOptions,\n          configurationDiagnostics,\n        );\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          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\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        return result;\n      });\n\n      build.onLoad(\n        { filter: compilerOptions.allowJs ? /\\.[cm]?[jt]sx?$/ : /\\.[cm]?tsx?$/ },\n        (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              // 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 (compilerOptions.allowJs && /\\.[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(build, styleOptions, stylesheetResourceFiles);\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

@@ -6,14 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 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<{
         affectedFiles: ReadonlySet<ts.SourceFile>;

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,8 +36,9 @@ 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) {
@@ -93,4 +94,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 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    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"]}