@angular-devkit/build-angular 17.1.0-next.2 → 17.1.0-rc.0

package/src/tools/esbuild/angular/component-stylesheets.js

@@ -14,17 +14,8 @@ exports.ComponentStylesheetBundler = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = __importDefault(require("node:path"));
 const bundler_context_1 = require("../bundler-context");
+const cache_1 = require("../cache");
 const bundle_options_1 = require("../stylesheets/bundle-options");
-class BundlerContextCache extends Map {
-    getOrCreate(key, creator) {
-        let value = this.get(key);
-        if (value === undefined) {
-            value = creator();
-            this.set(key, value);
-        }
-        return value;
-    }
-}
 /**
  * Bundles component stylesheets. A stylesheet can be either an inline stylesheet that
  * is contained within the Component's metadata definition or an external file referenced
@@ -33,8 +24,8 @@ class BundlerContextCache extends Map {
 class ComponentStylesheetBundler {
     options;
     incremental;
-    #fileContexts = new BundlerContextCache();
-    #inlineContexts = new BundlerContextCache();
+    #fileContexts = new cache_1.MemoryCache();
+    #inlineContexts = new cache_1.MemoryCache();
     /**
      *
      * @param options An object containing the stylesheet bundling options.
@@ -45,14 +36,14 @@ class ComponentStylesheetBundler {
         this.incremental = incremental;
     }
     async bundleFile(entry) {
-        const bundlerContext = this.#fileContexts.getOrCreate(entry, () => {
+        const bundlerContext = await this.#fileContexts.getOrCreate(entry, () => {
             return new bundler_context_1.BundlerContext(this.options.workspaceRoot, this.incremental, (loadCache) => {
                 const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)(this.options, loadCache);
                 buildOptions.entryPoints = [entry];
                 return buildOptions;
             });
         });
-        return extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
+        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
     }
     async bundleInline(data, filename, language) {
         // Use a hash of the inline stylesheet content to ensure a consistent identifier. External stylesheets will resolve
@@ -60,7 +51,7 @@ class ComponentStylesheetBundler {
         // TODO: Consider xxhash instead for hashing
         const id = (0, node_crypto_1.createHash)('sha256').update(data).digest('hex');
         const entry = [language, id, filename].join(';');
-        const bundlerContext = this.#inlineContexts.getOrCreate(entry, () => {
+        const bundlerContext = await this.#inlineContexts.getOrCreate(entry, () => {
             const namespace = 'angular:styles/component';
             return new bundler_context_1.BundlerContext(this.options.workspaceRoot, this.incremental, (loadCache) => {
                 const buildOptions = (0, bundle_options_1.createStylesheetBundleOptions)(this.options, loadCache, {
@@ -92,7 +83,7 @@ class ComponentStylesheetBundler {
             });
         });
         // Extract the result of the bundling from the output files
-        return extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
+        return this.extractResult(await bundlerContext.bundle(), bundlerContext.watchFiles);
     }
     invalidate(files) {
         if (!this.incremental) {
@@ -112,51 +103,46 @@ class ComponentStylesheetBundler {
         this.#inlineContexts.clear();
         await Promise.allSettled(contexts.map((context) => context.dispose()));
     }
-}
-exports.ComponentStylesheetBundler = ComponentStylesheetBundler;
-function extractResult(result, referencedFiles) {
-    let contents = '';
-    let map;
-    let outputPath;
-    const resourceFiles = [];
-    if (!result.errors) {
-        for (const outputFile of result.outputFiles) {
-            const filename = node_path_1.default.basename(outputFile.path);
-            if (outputFile.type === bundler_context_1.BuildOutputFileType.Media) {
-                // The output files could also contain resources (images/fonts/etc.) that were referenced
-                resourceFiles.push(outputFile);
-            }
-            else if (filename.endsWith('.css')) {
-                outputPath = outputFile.path;
-                contents = outputFile.text;
-            }
-            else if (filename.endsWith('.css.map')) {
-                map = outputFile.text;
-            }
-            else {
-                throw new Error(`Unexpected non CSS/Media file "${filename}" outputted during component stylesheet processing.`);
+    extractResult(result, referencedFiles) {
+        let contents = '';
+        let metafile;
+        const outputFiles = [];
+        if (!result.errors) {
+            for (const outputFile of result.outputFiles) {
+                const filename = node_path_1.default.basename(outputFile.path);
+                // Needed for Bazel as otherwise the files will not be written in the correct place.
+                outputFile.path = node_path_1.default.join(this.options.workspaceRoot, outputFile.path);
+                if (outputFile.type === bundler_context_1.BuildOutputFileType.Media) {
+                    // The output files could also contain resources (images/fonts/etc.) that were referenced
+                    outputFiles.push(outputFile);
+                }
+                else if (filename.endsWith('.css')) {
+                    contents = outputFile.text;
+                }
+                else if (filename.endsWith('.css.map')) {
+                    outputFiles.push(outputFile);
+                }
+                else {
+                    throw new Error(`Unexpected non CSS/Media file "${filename}" outputted during component stylesheet processing.`);
+                }
             }
+            metafile = result.metafile;
+            // Remove entryPoint fields from outputs to prevent the internal component styles from being
+            // treated as initial files. Also mark the entry as a component resource for stat reporting.
+            Object.values(metafile.outputs).forEach((output) => {
+                delete output.entryPoint;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                output['ng-component'] = true;
+            });
         }
+        return {
+            errors: result.errors,
+            warnings: result.warnings,
+            contents,
+            outputFiles,
+            metafile,
+            referencedFiles,
+        };
     }
-    let metafile;
-    if (!result.errors) {
-        metafile = result.metafile;
-        // Remove entryPoint fields from outputs to prevent the internal component styles from being
-        // treated as initial files. Also mark the entry as a component resource for stat reporting.
-        Object.values(metafile.outputs).forEach((output) => {
-            delete output.entryPoint;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            output['ng-component'] = true;
-        });
-    }
-    return {
-        errors: result.errors,
-        warnings: result.warnings,
-        contents,
-        map,
-        path: outputPath,
-        resourceFiles,
-        metafile,
-        referencedFiles,
-    };
 }
+exports.ComponentStylesheetBundler = ComponentStylesheetBundler;

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

@@ -92,8 +92,8 @@ function setupJitPluginCallbacks(build, stylesheetBundler, additionalResultFiles
         else {
             stylesheetResult = await stylesheetBundler.bundleInline(entry.contents, entry.path, inlineStyleLanguage);
         }
-        const { contents, resourceFiles, errors, warnings, metafile, referencedFiles } = stylesheetResult;
-        additionalResultFiles.set(entry.path, { outputFiles: resourceFiles, metafile });
+        const { contents, outputFiles, errors, warnings, metafile, referencedFiles } = stylesheetResult;
+        additionalResultFiles.set(entry.path, { outputFiles, metafile });
         return {
             errors,
             warnings,

package/src/tools/esbuild/bundler-context.d.ts

@@ -20,6 +20,7 @@ export type BundleContextResult = {
         server?: Set<string>;
         browser?: Set<string>;
     };
+    externalConfiguration?: string[];
 };
 export interface InitialFileRecord {
     entrypoint: boolean;
@@ -35,7 +36,6 @@ export declare enum BuildOutputFileType {
 }
 export interface BuildOutputFile extends OutputFile {
     type: BuildOutputFileType;
-    fullOutputPath: string;
     clone: () => BuildOutputFile;
 }
 export type BundlerOptionsFactory<T extends BuildOptions = BuildOptions> = (loadCache: LoadResultCache | undefined) => T;

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

@@ -6,9 +6,13 @@
  * 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.BundlerContext = exports.BuildOutputFileType = void 0;
 const esbuild_1 = require("esbuild");
+const node_assert_1 = __importDefault(require("node:assert"));
 const node_path_1 = require("node:path");
 const load_result_cache_1 = require("./load-result-cache");
 const utils_1 = require("./utils");
@@ -71,6 +75,7 @@ class BundlerContext {
         const externalImportsBrowser = new Set();
         const externalImportsServer = new Set();
         const outputFiles = [];
+        let externalConfiguration;
         for (const result of individualResults) {
             warnings.push(...result.warnings);
             if (result.errors) {
@@ -87,6 +92,12 @@ class BundlerContext {
             outputFiles.push(...result.outputFiles);
             result.externalImports.browser?.forEach((value) => externalImportsBrowser.add(value));
             result.externalImports.server?.forEach((value) => externalImportsServer.add(value));
+            if (result.externalConfiguration) {
+                externalConfiguration ??= new Set();
+                for (const value of result.externalConfiguration) {
+                    externalConfiguration.add(value);
+                }
+            }
         }
         if (errors !== undefined) {
             return { errors, warnings };
@@ -101,6 +112,7 @@ class BundlerContext {
                 browser: externalImportsBrowser,
                 server: externalImportsServer,
             },
+            externalConfiguration: externalConfiguration ? [...externalConfiguration] : undefined,
         };
     }
     /**
@@ -250,10 +262,13 @@ class BundlerContext {
                 externalImports.add(importData.path);
             }
         }
-        const platformIsServer = this.#esbuildOptions?.platform === 'node';
+        (0, node_assert_1.default)(this.#esbuildOptions, 'esbuild options cannot be undefined.');
+        const { platform, assetNames = '' } = this.#esbuildOptions;
+        const platformIsServer = platform === 'node';
+        const mediaDirname = (0, node_path_1.dirname)(assetNames);
         const outputFiles = result.outputFiles.map((file) => {
             let fileType;
-            if ((0, node_path_1.dirname)(file.path) === 'media') {
+            if ((0, node_path_1.dirname)(file.path) === mediaDirname) {
                 fileType = BuildOutputFileType.Media;
             }
             else {
@@ -269,6 +284,7 @@ class BundlerContext {
             externalImports: {
                 [platformIsServer ? 'server' : 'browser']: externalImports,
             },
+            externalConfiguration: this.#esbuildOptions.external,
             errors: undefined,
         };
     }

package/src/tools/esbuild/cache.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @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
+ */
+/**
+ * @fileoverview
+ * Provides infrastructure for common caching functionality within the build system.
+ */
+/**
+ * A backing data store for one or more Cache instances.
+ * The interface is intentionally designed to support using a JavaScript
+ * Map instance as a potential cache store.
+ */
+export interface CacheStore<V> {
+    /**
+     * Returns the specified value from the cache store or `undefined` if not found.
+     * @param key The key to retrieve from the store.
+     */
+    get(key: string): V | undefined | Promise<V | undefined>;
+    /**
+     * Returns whether the provided key is present in the cache store.
+     * @param key The key to check from the store.
+     */
+    has(key: string): boolean | Promise<boolean>;
+    /**
+     * Adds a new value to the cache store if the key is not present.
+     * Updates the value for the key if already present.
+     * @param key The key to associate with the value in the cache store.
+     * @param value The value to add to the cache store.
+     */
+    set(key: string, value: V): this | Promise<this>;
+}
+/**
+ * A cache object that allows accessing and storing key/value pairs in
+ * an underlying CacheStore. This class is the primary method for consumers
+ * to use a cache.
+ */
+export declare class Cache<V, S extends CacheStore<V> = CacheStore<V>> {
+    protected readonly store: S;
+    readonly namespace?: string | undefined;
+    constructor(store: S, namespace?: string | undefined);
+    /**
+     * Prefixes a key with the cache namespace if present.
+     * @param key A key string to prefix.
+     * @returns A prefixed key if a namespace is present. Otherwise the provided key.
+     */
+    protected withNamespace(key: string): string;
+    /**
+     * Gets the value associated with a provided key if available.
+     * Otherwise, creates a value using the factory creator function, puts the value
+     * in the cache, and returns the new value.
+     * @param key A key associated with the value.
+     * @param creator A factory function for the value if no value is present.
+     * @returns A value associated with the provided key.
+     */
+    getOrCreate(key: string, creator: () => V | Promise<V>): Promise<V>;
+    /**
+     * Gets the value associated with a provided key if available.
+     * @param key A key associated with the value.
+     * @returns A value associated with the provided key if present. Otherwise, `undefined`.
+     */
+    get(key: string): Promise<V | undefined>;
+    /**
+     * Puts a value in the cache and associates it with the provided key.
+     * If the key is already present, the value is updated instead.
+     * @param key A key associated with the value.
+     * @param value A value to put in the cache.
+     */
+    put(key: string, value: V): Promise<void>;
+}
+/**
+ * A lightweight in-memory cache implementation based on a JavaScript Map object.
+ */
+export declare class MemoryCache<V> extends Cache<V, Map<string, V>> {
+    constructor();
+    /**
+     * Removes all entries from the cache instance.
+     */
+    clear(): void;
+    /**
+     * Provides all the values currently present in the cache instance.
+     * @returns An iterable of all values in the cache.
+     */
+    values(): IterableIterator<V>;
+}

package/src/tools/esbuild/cache.js

@@ -0,0 +1,92 @@
+"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.MemoryCache = exports.Cache = void 0;
+/**
+ * A cache object that allows accessing and storing key/value pairs in
+ * an underlying CacheStore. This class is the primary method for consumers
+ * to use a cache.
+ */
+class Cache {
+    store;
+    namespace;
+    constructor(store, namespace) {
+        this.store = store;
+        this.namespace = namespace;
+    }
+    /**
+     * Prefixes a key with the cache namespace if present.
+     * @param key A key string to prefix.
+     * @returns A prefixed key if a namespace is present. Otherwise the provided key.
+     */
+    withNamespace(key) {
+        if (this.namespace) {
+            return `${this.namespace}:${key}`;
+        }
+        return key;
+    }
+    /**
+     * Gets the value associated with a provided key if available.
+     * Otherwise, creates a value using the factory creator function, puts the value
+     * in the cache, and returns the new value.
+     * @param key A key associated with the value.
+     * @param creator A factory function for the value if no value is present.
+     * @returns A value associated with the provided key.
+     */
+    async getOrCreate(key, creator) {
+        const namespacedKey = this.withNamespace(key);
+        let value = await this.store.get(namespacedKey);
+        if (value === undefined) {
+            value = await creator();
+            await this.store.set(namespacedKey, value);
+        }
+        return value;
+    }
+    /**
+     * Gets the value associated with a provided key if available.
+     * @param key A key associated with the value.
+     * @returns A value associated with the provided key if present. Otherwise, `undefined`.
+     */
+    async get(key) {
+        const value = await this.store.get(this.withNamespace(key));
+        return value;
+    }
+    /**
+     * Puts a value in the cache and associates it with the provided key.
+     * If the key is already present, the value is updated instead.
+     * @param key A key associated with the value.
+     * @param value A value to put in the cache.
+     */
+    async put(key, value) {
+        await this.store.set(this.withNamespace(key), value);
+    }
+}
+exports.Cache = Cache;
+/**
+ * A lightweight in-memory cache implementation based on a JavaScript Map object.
+ */
+class MemoryCache extends Cache {
+    constructor() {
+        super(new Map());
+    }
+    /**
+     * Removes all entries from the cache instance.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Provides all the values currently present in the cache instance.
+     * @returns An iterable of all values in the cache.
+     */
+    values() {
+        return this.store.values();
+    }
+}
+exports.MemoryCache = MemoryCache;

package/src/tools/esbuild/compiler-plugin-options.js

@@ -32,7 +32,7 @@ function createCompilerPluginOptions(options, target, sourceFileCache) {
             // Hidden component stylesheet sourcemaps are inaccessible which is effectively
             // the same as being disabled. Disabling has the advantage of avoiding the overhead
             // of sourcemap processing.
-            !!sourcemapOptions.styles && (sourcemapOptions.hidden ? false : 'inline'),
+            sourcemapOptions.styles && !sourcemapOptions.hidden ? 'linked' : false,
             outputNames,
             includePaths: stylePreprocessorOptions?.includePaths,
             externalDependencies,

package/src/tools/esbuild/index-html-generator.js

@@ -45,7 +45,7 @@ async function generateIndexHtml(initialFiles, outputFiles, buildOptions, lang)
     const hints = [];
     const { indexHtmlOptions, externalPackages, optimizationOptions, crossOrigin, subresourceIntegrity, baseHref, } = buildOptions;
     (0, node_assert_1.default)(indexHtmlOptions, 'indexHtmlOptions cannot be undefined.');
-    if (!externalPackages) {
+    if (!externalPackages && indexHtmlOptions.preloadInitial) {
         for (const [key, value] of initialFiles) {
             if (value.entrypoint) {
                 // Entry points are already referenced in the HTML
@@ -87,6 +87,7 @@ async function generateIndexHtml(initialFiles, outputFiles, buildOptions, lang)
         },
         crossOrigin: crossOrigin,
         deployUrl: buildOptions.publicPath,
+        postTransform: indexHtmlOptions.transformer,
     });
     indexHtmlGenerator.readAsset = readAsset;
     const transformResult = await indexHtmlGenerator.process({
@@ -110,6 +111,7 @@ async function generateIndexHtml(initialFiles, outputFiles, buildOptions, lang)
     const { InlineCriticalCssProcessor } = await Promise.resolve().then(() => __importStar(require('../../utils/index-file/inline-critical-css')));
     const inlineCriticalCssProcessor = new InlineCriticalCssProcessor({
         minify: false, // CSS has already been minified during the build.
+        deployUrl: buildOptions.publicPath,
         readAsset,
     });
     const { content, errors, warnings } = await inlineCriticalCssProcessor.process(contentWithoutCriticalCssInlined, {

package/src/tools/esbuild/javascript-transformer-worker.d.ts

@@ -7,7 +7,7 @@
  */
 interface JavaScriptTransformRequest {
     filename: string;
-    data: string;
+    data: string | Uint8Array;
     sourcemap: boolean;
     thirdPartySourcemaps: boolean;
     advancedOptimizations: boolean;
@@ -15,5 +15,5 @@ interface JavaScriptTransformRequest {
     sideEffects?: boolean;
     jit: boolean;
 }
-export default function transformJavaScript(request: JavaScriptTransformRequest): Promise<Uint8Array>;
+export default function transformJavaScript(request: JavaScriptTransformRequest): Promise<unknown>;
 export {};

package/src/tools/esbuild/javascript-transformer-worker.js

@@ -29,19 +29,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 });
 const core_1 = require("@babel/core");
-const promises_1 = require("node:fs/promises");
+const piscina_1 = __importDefault(require("piscina"));
 const application_1 = __importStar(require("../../tools/babel/presets/application"));
 const load_esm_1 = require("../../utils/load-esm");
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
 async function transformJavaScript(request) {
-    request.data ??= await (0, promises_1.readFile)(request.filename, 'utf-8');
-    const transformedData = await transformWithBabel(request);
-    return Buffer.from(transformedData, 'utf-8');
+    const { filename, data, ...options } = request;
+    const textData = typeof data === 'string' ? data : textDecoder.decode(data);
+    const transformedData = await transformWithBabel(filename, textData, options);
+    // Transfer the data via `move` instead of cloning
+    return piscina_1.default.move(textEncoder.encode(transformedData));
 }
 exports.default = transformJavaScript;
 let linkerPluginCreator;
-async function transformWithBabel({ filename, data, ...options }) {
+async function transformWithBabel(filename, data, options) {
     const shouldLink = !options.skipLinker && (await (0, application_1.requiresLinking)(filename, data));
     const useInputSourcemap = options.sourcemap &&
         (!!options.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));

package/src/tools/esbuild/javascript-transformer.d.ts

@@ -5,6 +5,7 @@
  * 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 { Cache } from './cache';
 /**
  * Transformation options that should apply to all transformed files and data.
  */
@@ -24,7 +25,8 @@ export interface JavaScriptTransformerOptions {
 export declare class JavaScriptTransformer {
     #private;
     readonly maxThreads: number;
-    constructor(options: JavaScriptTransformerOptions, maxThreads: number, reuseResults?: boolean);
+    private readonly cache?;
+    constructor(options: JavaScriptTransformerOptions, maxThreads: number, cache?: Cache<Uint8Array, import("./cache").CacheStore<Uint8Array>> | undefined);
     /**
      * Performs JavaScript transformations on a file from the filesystem.
      * If no transformations are required, the data for the original file will be returned.

package/src/tools/esbuild/javascript-transformer.js

@@ -11,6 +11,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaScriptTransformer = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
 const piscina_1 = __importDefault(require("piscina"));
 /**
  * A class that performs transformation of JavaScript files and raw data.
@@ -21,11 +23,13 @@ const piscina_1 = __importDefault(require("piscina"));
  */
 class JavaScriptTransformer {
     maxThreads;
+    cache;
     #workerPool;
     #commonOptions;
-    #pendingfileResults;
-    constructor(options, maxThreads, reuseResults) {
+    #fileCacheKeyBase;
+    constructor(options, maxThreads, cache) {
         this.maxThreads = maxThreads;
+        this.cache = cache;
         // Extract options to ensure only the named options are serialized and sent to the worker
         const { sourcemap, thirdPartySourcemaps = false, advancedOptimizations = false, jit = false, } = options;
         this.#commonOptions = {
@@ -34,10 +38,7 @@ class JavaScriptTransformer {
             advancedOptimizations,
             jit,
         };
-        // Currently only tracks pending file transform results
-        if (reuseResults) {
-            this.#pendingfileResults = new Map();
-        }
+        this.#fileCacheKeyBase = Buffer.from(JSON.stringify(this.#commonOptions), 'utf-8');
     }
     #ensureWorkerPool() {
         this.#workerPool ??= new piscina_1.default({
@@ -57,21 +58,46 @@ class JavaScriptTransformer {
      * @param sideEffects If false, and `advancedOptimizations` is enabled tslib decorators are wrapped.
      * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
      */
-    transformFile(filename, skipLinker, sideEffects) {
-        const pendingKey = `${!!skipLinker}--${filename}`;
-        let pending = this.#pendingfileResults?.get(pendingKey);
-        if (pending === undefined) {
-            // Always send the request to a worker. Files are almost always from node modules which means
-            // they may need linking. The data is also not yet available to perform most transformation checks.
-            pending = this.#ensureWorkerPool().run({
+    async transformFile(filename, skipLinker, sideEffects) {
+        const data = await (0, promises_1.readFile)(filename);
+        let result;
+        let cacheKey;
+        if (this.cache) {
+            // Create a cache key from the file data and options that effect the output.
+            // NOTE: If additional options are added, this may need to be updated.
+            // TODO: Consider xxhash or similar instead of SHA256
+            const hash = (0, node_crypto_1.createHash)('sha256');
+            hash.update(`${!!skipLinker}--${!!sideEffects}`);
+            hash.update(data);
+            hash.update(this.#fileCacheKeyBase);
+            cacheKey = hash.digest('hex');
+            try {
+                result = await this.cache?.get(cacheKey);
+            }
+            catch {
+                // Failure to get the value should not fail the transform
+            }
+        }
+        if (result === undefined) {
+            // If there is no cache or no cached entry, process the file
+            result = (await this.#ensureWorkerPool().run({
                 filename,
+                data,
                 skipLinker,
                 sideEffects,
                 ...this.#commonOptions,
-            });
-            this.#pendingfileResults?.set(pendingKey, pending);
+            }, { transferList: [data.buffer] }));
+            // If there is a cache then store the result
+            if (this.cache && cacheKey) {
+                try {
+                    await this.cache.put(cacheKey, result);
+                }
+                catch {
+                    // Failure to store the value in the cache should not fail the transform
+                }
+            }
         }
-        return pending;
+        return result;
     }
     /**
      * Performs JavaScript transformations on the provided data of a file. The file does not need
@@ -103,7 +129,6 @@ class JavaScriptTransformer {
      * @returns A void promise that resolves when closing is complete.
      */
     async close() {
-        this.#pendingfileResults?.clear();
         if (this.#workerPool) {
             try {
                 await this.#workerPool.destroy();

package/src/tools/esbuild/stylesheets/bundle-options.d.ts

@@ -13,7 +13,7 @@ export interface BundleStylesheetOptions {
     optimization: boolean;
     inlineFonts: boolean;
     preserveSymlinks?: boolean;
-    sourcemap: boolean | 'external' | 'inline';
+    sourcemap: boolean | 'external' | 'inline' | 'linked';
     outputNames: {
         bundles: string;
         media: string;