@angular/build 18.0.0-next.3

package/src/tools/esbuild/angular/diagnostics.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTypeScriptDiagnostic = void 0;
+const node_os_1 = require("node:os");
+/**
+ * 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(typescript, info, textPrefix) {
+    const newLine = (0, node_os_1.platform)() === 'win32' ? '\r\n' : '\n';
+    let text = typescript.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.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.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.getLineAndCharacterOfPosition(info.file, info.file.text.length - 1);
+            const lineEndPosition = line < lastLineOfFile
+                ? typescript.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(typescript, 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(typescript, diagnostic, `${codePrefix}${code}: `);
+    if (diagnostic.relatedInformation?.length) {
+        message.notes = diagnostic.relatedInformation.map((info) => convertTypeScriptDiagnosticInfo(typescript, info));
+    }
+    return message;
+}
+exports.convertTypeScriptDiagnostic = convertTypeScriptDiagnostic;

package/src/tools/esbuild/angular/file-reference-tracker.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare class FileReferenceTracker {
+    #private;
+    get referencedFiles(): IterableIterator<string>;
+    add(containingFile: string, referencedFiles: Iterable<string>): void;
+    /**
+     *
+     * @param changed The set of changed files.
+     */
+    update(changed: Set<string>): Set<string>;
+}

package/src/tools/esbuild/angular/file-reference-tracker.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReferenceTracker = void 0;
+const node_path_1 = require("node:path");
+class FileReferenceTracker {
+    #referencingFiles = new Map();
+    get referencedFiles() {
+        return this.#referencingFiles.keys();
+    }
+    add(containingFile, referencedFiles) {
+        const normalizedContainingFile = (0, node_path_1.normalize)(containingFile);
+        for (const file of referencedFiles) {
+            const normalizedReferencedFile = (0, node_path_1.normalize)(file);
+            if (normalizedReferencedFile === normalizedContainingFile) {
+                // Containing file is already known to the AOT compiler
+                continue;
+            }
+            const referencing = this.#referencingFiles.get(normalizedReferencedFile);
+            if (referencing === undefined) {
+                this.#referencingFiles.set(normalizedReferencedFile, new Set([normalizedContainingFile]));
+            }
+            else {
+                referencing.add(normalizedContainingFile);
+            }
+        }
+    }
+    /**
+     *
+     * @param changed The set of changed files.
+     */
+    update(changed) {
+        // Lazily initialized to avoid unneeded copying if there are no additions to return
+        let allChangedFiles;
+        // Add referencing files to fully notify the AOT compiler of required component updates
+        for (const modifiedFile of changed) {
+            const normalizedModifiedFile = (0, node_path_1.normalize)(modifiedFile);
+            const referencing = this.#referencingFiles.get(normalizedModifiedFile);
+            if (referencing) {
+                allChangedFiles ??= new Set(changed);
+                for (const referencingFile of referencing) {
+                    allChangedFiles.add(referencingFile);
+                }
+                // Cleanup the stale record which will be updated by new resource transforms
+                this.#referencingFiles.delete(normalizedModifiedFile);
+            }
+        }
+        return allChangedFiles ?? changed;
+    }
+}
+exports.FileReferenceTracker = FileReferenceTracker;

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import type { Metafile, OutputFile, PluginBuild } from 'esbuild';
+import { LoadResultCache } from '../load-result-cache';
+import { ComponentStylesheetBundler } from './component-stylesheets';
+/**
+ * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing
+ * for both Component stylesheets and templates. These callbacks work alongside the JIT
+ * resource TypeScript transformer to convert and then bundle Component resources as
+ * static imports.
+ * @param build An esbuild {@link PluginBuild} instance used to add callbacks.
+ * @param styleOptions The options to use when bundling stylesheets.
+ * @param additionalResultFiles A Map where stylesheet resources will be added.
+ */
+export declare function setupJitPluginCallbacks(build: PluginBuild, stylesheetBundler: ComponentStylesheetBundler, additionalResultFiles: Map<string, {
+    outputFiles?: OutputFile[];
+    metafile?: Metafile;
+}>, inlineStyleLanguage: string, loadCache?: LoadResultCache): void;

package/src/tools/esbuild/angular/jit-plugin-callbacks.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupJitPluginCallbacks = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const load_result_cache_1 = require("../load-result-cache");
+const uri_1 = require("./uri");
+/**
+ * Loads/extracts the contents from a load callback Angular JIT entry.
+ * An Angular JIT entry represents either a file path for a component resource or base64
+ * encoded data for an inline component resource.
+ * @param entry The value that represents content to load.
+ * @param root The absolute path for the root of the build (typically the workspace root).
+ * @param skipRead If true, do not attempt to read the file; if false, read file content from disk.
+ * This option has no effect if the entry does not originate from a file. Defaults to false.
+ * @returns An object containing the absolute path of the contents and optionally the actual contents.
+ * For inline entries the contents will always be provided.
+ */
+async function loadEntry(entry, root, skipRead) {
+    if (entry.startsWith('file:')) {
+        const specifier = (0, node_path_1.join)(root, entry.slice(5));
+        return {
+            path: specifier,
+            contents: skipRead ? undefined : await (0, promises_1.readFile)(specifier, 'utf-8'),
+        };
+    }
+    else if (entry.startsWith('inline:')) {
+        const [importer, data] = entry.slice(7).split(';', 2);
+        return {
+            path: (0, node_path_1.join)(root, importer),
+            contents: Buffer.from(data, 'base64').toString(),
+        };
+    }
+    else {
+        throw new Error('Invalid data for Angular JIT entry.');
+    }
+}
+/**
+ * Sets up esbuild resolve and load callbacks to support Angular JIT mode processing
+ * for both Component stylesheets and templates. These callbacks work alongside the JIT
+ * resource TypeScript transformer to convert and then bundle Component resources as
+ * static imports.
+ * @param build An esbuild {@link PluginBuild} instance used to add callbacks.
+ * @param styleOptions The options to use when bundling stylesheets.
+ * @param additionalResultFiles A Map where stylesheet resources will be added.
+ */
+function setupJitPluginCallbacks(build, stylesheetBundler, additionalResultFiles, inlineStyleLanguage, loadCache) {
+    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.
+    // Resources originating from a file are resolved as relative from the containing file (importer).
+    build.onResolve({ filter: uri_1.JIT_NAMESPACE_REGEXP }, (args) => {
+        const parsed = (0, uri_1.parseJitUri)(args.path);
+        if (!parsed) {
+            return undefined;
+        }
+        const { namespace, origin, specifier } = parsed;
+        if (origin === 'file') {
+            return {
+                // Use a relative path to prevent fully resolved paths in the metafile (JSON stats file).
+                // This is only necessary for custom namespaces. esbuild will handle the file namespace.
+                path: 'file:' + (0, node_path_1.relative)(root, (0, node_path_1.join)((0, node_path_1.dirname)(args.importer), specifier)),
+                namespace,
+            };
+        }
+        else {
+            // Inline data may need the importer to resolve imports/references within the content
+            const importer = (0, node_path_1.relative)(root, args.importer);
+            return {
+                path: `inline:${importer};${specifier}`,
+                namespace,
+            };
+        }
+    });
+    // Add a load callback to handle Component stylesheets (both inline and external)
+    build.onLoad({ filter: /./, namespace: uri_1.JIT_STYLE_NAMESPACE }, (0, load_result_cache_1.createCachedLoad)(loadCache, async (args) => {
+        // skipRead is used here because the stylesheet bundling will read a file stylesheet
+        // directly either via a preprocessor or esbuild itself.
+        const entry = await loadEntry(args.path, root, true /* skipRead */);
+        let stylesheetResult;
+        // Stylesheet contents only exist for internal stylesheets
+        if (entry.contents === undefined) {
+            stylesheetResult = await stylesheetBundler.bundleFile(entry.path);
+        }
+        else {
+            stylesheetResult = await stylesheetBundler.bundleInline(entry.contents, entry.path, inlineStyleLanguage);
+        }
+        const { contents, outputFiles, errors, warnings, metafile, referencedFiles } = stylesheetResult;
+        additionalResultFiles.set(entry.path, { outputFiles, metafile });
+        return {
+            errors,
+            warnings,
+            contents,
+            loader: 'text',
+            watchFiles: referencedFiles && [...referencedFiles],
+        };
+    }));
+    // Add a load callback to handle Component templates
+    // NOTE: While this callback supports both inline and external templates, the transformer
+    // currently only supports generating URIs for external templates.
+    build.onLoad({ filter: /./, namespace: uri_1.JIT_TEMPLATE_NAMESPACE }, (0, load_result_cache_1.createCachedLoad)(loadCache, async (args) => {
+        const { contents, path } = await loadEntry(args.path, root);
+        return {
+            contents,
+            loader: 'text',
+            watchFiles: [path],
+        };
+    }));
+}
+exports.setupJitPluginCallbacks = setupJitPluginCallbacks;

package/src/tools/esbuild/angular/jit-resource-transformer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import ts from 'typescript';
+/**
+ * Creates a TypeScript Transformer to transform Angular Component resource references into
+ * static import statements. This transformer is used in Angular's JIT compilation mode to
+ * support processing of component resources. When in AOT mode, the Angular AOT compiler handles
+ * this processing and this transformer is not used.
+ * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program.
+ * @returns A TypeScript transformer factory.
+ */
+export declare function createJitResourceTransformer(getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory<ts.SourceFile>;

package/src/tools/esbuild/angular/jit-resource-transformer.js

@@ -0,0 +1,186 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJitResourceTransformer = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const uri_1 = require("./uri");
+/**
+ * Creates a TypeScript Transformer to transform Angular Component resource references into
+ * static import statements. This transformer is used in Angular's JIT compilation mode to
+ * support processing of component resources. When in AOT mode, the Angular AOT compiler handles
+ * this processing and this transformer is not used.
+ * @param getTypeChecker A function that returns a TypeScript TypeChecker instance for the program.
+ * @returns A TypeScript transformer factory.
+ */
+function createJitResourceTransformer(getTypeChecker) {
+    return (context) => {
+        const typeChecker = getTypeChecker();
+        const nodeFactory = context.factory;
+        const resourceImportDeclarations = [];
+        const visitNode = (node) => {
+            if (typescript_1.default.isClassDeclaration(node)) {
+                const decorators = typescript_1.default.getDecorators(node);
+                if (!decorators || decorators.length === 0) {
+                    return node;
+                }
+                return nodeFactory.updateClassDeclaration(node, [
+                    ...decorators.map((current) => visitDecorator(nodeFactory, current, typeChecker, resourceImportDeclarations)),
+                    ...(typescript_1.default.getModifiers(node) ?? []),
+                ], node.name, node.typeParameters, node.heritageClauses, node.members);
+            }
+            return typescript_1.default.visitEachChild(node, visitNode, context);
+        };
+        return (sourceFile) => {
+            const updatedSourceFile = typescript_1.default.visitEachChild(sourceFile, visitNode, context);
+            if (resourceImportDeclarations.length > 0) {
+                return nodeFactory.updateSourceFile(updatedSourceFile, typescript_1.default.setTextRange(nodeFactory.createNodeArray([...resourceImportDeclarations, ...updatedSourceFile.statements], updatedSourceFile.statements.hasTrailingComma), updatedSourceFile.statements), updatedSourceFile.isDeclarationFile, updatedSourceFile.referencedFiles, updatedSourceFile.typeReferenceDirectives, updatedSourceFile.hasNoDefaultLib, updatedSourceFile.libReferenceDirectives);
+            }
+            else {
+                return updatedSourceFile;
+            }
+        };
+    };
+}
+exports.createJitResourceTransformer = createJitResourceTransformer;
+function visitDecorator(nodeFactory, node, typeChecker, resourceImportDeclarations) {
+    const origin = getDecoratorOrigin(node, typeChecker);
+    if (!origin || origin.module !== '@angular/core' || origin.name !== 'Component') {
+        return node;
+    }
+    if (!typescript_1.default.isCallExpression(node.expression)) {
+        return node;
+    }
+    const decoratorFactory = node.expression;
+    const args = decoratorFactory.arguments;
+    if (args.length !== 1 || !typescript_1.default.isObjectLiteralExpression(args[0])) {
+        // Unsupported component metadata
+        return node;
+    }
+    const objectExpression = args[0];
+    const styleReplacements = [];
+    // visit all properties
+    let properties = typescript_1.default.visitNodes(objectExpression.properties, (node) => typescript_1.default.isObjectLiteralElementLike(node)
+        ? visitComponentMetadata(nodeFactory, node, styleReplacements, resourceImportDeclarations)
+        : node);
+    // replace properties with updated properties
+    if (styleReplacements.length > 0) {
+        const styleProperty = nodeFactory.createPropertyAssignment(nodeFactory.createIdentifier('styles'), nodeFactory.createArrayLiteralExpression(styleReplacements));
+        properties = nodeFactory.createNodeArray([...properties, styleProperty]);
+    }
+    return nodeFactory.updateDecorator(node, nodeFactory.updateCallExpression(decoratorFactory, decoratorFactory.expression, decoratorFactory.typeArguments, [nodeFactory.updateObjectLiteralExpression(objectExpression, properties)]));
+}
+function visitComponentMetadata(nodeFactory, node, styleReplacements, resourceImportDeclarations) {
+    if (!typescript_1.default.isPropertyAssignment(node) || typescript_1.default.isComputedPropertyName(node.name)) {
+        return node;
+    }
+    switch (node.name.text) {
+        case 'templateUrl':
+            // Only analyze string literals
+            if (!typescript_1.default.isStringLiteralLike(node.initializer)) {
+                return node;
+            }
+            return node.initializer.text.length === 0
+                ? node
+                : nodeFactory.updatePropertyAssignment(node, nodeFactory.createIdentifier('template'), createResourceImport(nodeFactory, (0, uri_1.generateJitFileUri)(node.initializer.text, 'template'), resourceImportDeclarations));
+        case 'styles':
+            if (typescript_1.default.isStringLiteralLike(node.initializer)) {
+                styleReplacements.unshift(createResourceImport(nodeFactory, (0, uri_1.generateJitInlineUri)(node.initializer.text, 'style'), resourceImportDeclarations));
+                return undefined;
+            }
+            if (typescript_1.default.isArrayLiteralExpression(node.initializer)) {
+                const inlineStyles = typescript_1.default.visitNodes(node.initializer.elements, (node) => {
+                    if (!typescript_1.default.isStringLiteralLike(node)) {
+                        return node;
+                    }
+                    return node.text.length === 0
+                        ? undefined // An empty inline style is equivalent to not having a style element
+                        : createResourceImport(nodeFactory, (0, uri_1.generateJitInlineUri)(node.text, 'style'), resourceImportDeclarations);
+                });
+                // Inline styles should be placed first
+                styleReplacements.unshift(...inlineStyles);
+                // The inline styles will be added afterwards in combination with any external styles
+                return undefined;
+            }
+            return node;
+        case 'styleUrl':
+            if (typescript_1.default.isStringLiteralLike(node.initializer)) {
+                styleReplacements.push(createResourceImport(nodeFactory, (0, uri_1.generateJitFileUri)(node.initializer.text, 'style'), resourceImportDeclarations));
+                return undefined;
+            }
+            return node;
+        case 'styleUrls':
+            if (!typescript_1.default.isArrayLiteralExpression(node.initializer)) {
+                return node;
+            }
+            const externalStyles = typescript_1.default.visitNodes(node.initializer.elements, (node) => {
+                if (!typescript_1.default.isStringLiteralLike(node)) {
+                    return node;
+                }
+                return node.text
+                    ? createResourceImport(nodeFactory, (0, uri_1.generateJitFileUri)(node.text, 'style'), resourceImportDeclarations)
+                    : undefined;
+            });
+            // External styles are applied after any inline styles
+            styleReplacements.push(...externalStyles);
+            // The external styles will be added afterwards in combination with any inline styles
+            return undefined;
+        default:
+            // All other elements are passed through
+            return node;
+    }
+}
+function createResourceImport(nodeFactory, url, resourceImportDeclarations) {
+    const urlLiteral = nodeFactory.createStringLiteral(url);
+    const importName = nodeFactory.createIdentifier(`__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`);
+    resourceImportDeclarations.push(nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, importName, undefined), urlLiteral));
+    return importName;
+}
+function getDecoratorOrigin(decorator, typeChecker) {
+    if (!typescript_1.default.isCallExpression(decorator.expression)) {
+        return null;
+    }
+    let identifier;
+    let name = '';
+    if (typescript_1.default.isPropertyAccessExpression(decorator.expression.expression)) {
+        identifier = decorator.expression.expression.expression;
+        name = decorator.expression.expression.name.text;
+    }
+    else if (typescript_1.default.isIdentifier(decorator.expression.expression)) {
+        identifier = decorator.expression.expression;
+    }
+    else {
+        return null;
+    }
+    // NOTE: resolver.getReferencedImportDeclaration would work as well but is internal
+    const symbol = typeChecker.getSymbolAtLocation(identifier);
+    if (symbol && symbol.declarations && symbol.declarations.length > 0) {
+        const declaration = symbol.declarations[0];
+        let module;
+        if (typescript_1.default.isImportSpecifier(declaration)) {
+            name = (declaration.propertyName || declaration.name).text;
+            module = declaration.parent.parent.parent.moduleSpecifier.text;
+        }
+        else if (typescript_1.default.isNamespaceImport(declaration)) {
+            // Use the name from the decorator namespace property access
+            module = declaration.parent.parent.moduleSpecifier.text;
+        }
+        else if (typescript_1.default.isImportClause(declaration)) {
+            name = declaration.name.text;
+            module = declaration.parent.moduleSpecifier.text;
+        }
+        else {
+            return null;
+        }
+        return { name, module };
+    }
+    return null;
+}

package/src/tools/esbuild/angular/source-file-cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import type ts from 'typescript';
+import { MemoryLoadResultCache } from '../load-result-cache';
+export declare class SourceFileCache extends Map<string, ts.SourceFile> {
+    readonly persistentCachePath?: string | undefined;
+    readonly modifiedFiles: Set<string>;
+    readonly typeScriptFileCache: Map<string, string | Uint8Array>;
+    readonly loadResultCache: MemoryLoadResultCache;
+    referencedFiles?: readonly string[];
+    constructor(persistentCachePath?: string | undefined);
+    invalidate(files: Iterable<string>): void;
+}

package/src/tools/esbuild/angular/source-file-cache.js

@@ -0,0 +1,65 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceFileCache = void 0;
+const node_os_1 = require("node:os");
+const path = __importStar(require("node:path"));
+const load_result_cache_1 = require("../load-result-cache");
+const USING_WINDOWS = (0, node_os_1.platform)() === 'win32';
+const WINDOWS_SEP_REGEXP = new RegExp(`\\${path.win32.sep}`, 'g');
+class SourceFileCache extends Map {
+    persistentCachePath;
+    modifiedFiles = new Set();
+    typeScriptFileCache = new Map();
+    loadResultCache = new load_result_cache_1.MemoryLoadResultCache();
+    referencedFiles;
+    constructor(persistentCachePath) {
+        super();
+        this.persistentCachePath = persistentCachePath;
+    }
+    invalidate(files) {
+        if (files !== this.modifiedFiles) {
+            this.modifiedFiles.clear();
+        }
+        for (let file of files) {
+            file = path.normalize(file);
+            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;

package/src/tools/esbuild/angular/uri.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @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
+ */
+/**
+ * A string value representing the namespace for Angular JIT mode related imports for
+ * Component styles. This namespace is used for both inline (`styles`) and external
+ * (`styleUrls`) styles.
+ */
+export declare const JIT_STYLE_NAMESPACE: "angular:jit:style";
+/**
+ * A string value representing the namespace for Angular JIT mode related imports for
+ * Component templates. This namespace is currently only used for external (`templateUrl`)
+ * templates.
+ */
+export declare const JIT_TEMPLATE_NAMESPACE: "angular:jit:template";
+/**
+ * A regular expression that can be used to match a Angular JIT mode namespace URI.
+ * It contains capture groups for the type (template/style), origin (file/inline), and specifier.
+ * The {@link parseJitUri} function can be used to parse and return an object representation of a JIT URI.
+ */
+export declare const JIT_NAMESPACE_REGEXP: RegExp;
+/**
+ * Generates an Angular JIT mode namespace URI for a given file.
+ * @param file The path of the file to be included.
+ * @param type The type of the file (`style` or `template`).
+ * @returns A string containing the full JIT namespace URI.
+ */
+export declare function generateJitFileUri(file: string, type: 'style' | 'template'): string;
+/**
+ * Generates an Angular JIT mode namespace URI for a given inline style or template.
+ * The provided content is base64 encoded and included in the URI.
+ * @param data The content to encode within the URI.
+ * @param type The type of the content (`style` or `template`).
+ * @returns A string containing the full JIT namespace URI.
+ */
+export declare function generateJitInlineUri(data: string | Uint8Array, type: 'style' | 'template'): string;
+/**
+ * Parses a string containing a JIT namespace URI.
+ * JIT namespace URIs are used to encode the information for an Angular component's stylesheets
+ * and templates when compiled in JIT mode.
+ * @param uri The URI to parse into its underlying components.
+ * @returns An object containing the namespace, type, origin, and specifier of the URI;
+ * `undefined` if not a JIT namespace URI.
+ */
+export declare function parseJitUri(uri: string): {
+    namespace: string;
+    type: "style" | "template";
+    origin: "file" | "inline";
+    specifier: string;
+} | undefined;