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

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/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/sass-language.js

@@ -33,6 +33,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SassStylesheetLanguage = exports.shutdownSassWorkerPool = void 0;
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
+const cache_1 = require("../cache");
 let sassWorkerPool;
 let sassWorkerPoolPromise;
 function isSassException(error) {
@@ -81,16 +82,6 @@ function parsePackageName(url) {
         },
     };
 }
-class Cache extends Map {
-    async getOrCreate(key, creator) {
-        let value = this.get(key);
-        if (value === undefined) {
-            value = await creator();
-            this.set(key, value);
-        }
-        return value;
-    }
-}
 async function compileString(data, filePath, syntax, options, resolveUrl) {
     // Lazily load Sass when a Sass file is found
     if (sassWorkerPool === undefined) {
@@ -105,8 +96,8 @@ async function compileString(data, filePath, syntax, options, resolveUrl) {
     // A null value indicates that the cached resolution attempt failed to find a location and
     // later stage resolution should be attempted. This avoids potentially expensive repeat
     // failing resolution attempts.
-    const resolutionCache = new Cache();
-    const packageRootCache = new Cache();
+    const resolutionCache = new cache_1.MemoryCache();
+    const packageRootCache = new cache_1.MemoryCache();
     const warnings = [];
     try {
         const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {

package/src/tools/sass/lexer.d.ts

@@ -16,14 +16,3 @@ export declare function findUrls(contents: string): Iterable<{
     end: number;
     value: string;
 }>;
-/**
- * Scans a CSS or Sass file and locates all valid import/use directive values as defined by the
- * syntax specification.
- * @param contents A string containing a CSS or Sass file to scan.
- * @returns An iterable that yields each CSS directive value found.
- */
-export declare function findImports(contents: string): Iterable<{
-    start: number;
-    end: number;
-    specifier: string;
-}>;

package/src/tools/sass/lexer.js

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findImports = exports.findUrls = void 0;
+exports.findUrls = void 0;
 // TODO: Combine everything into a single pass lexer
 /**
  * Determines if a unicode code point is a CSS whitespace character.
@@ -159,89 +159,3 @@ function* findUrls(contents) {
     }
 }
 exports.findUrls = findUrls;
-/**
- * Scans a CSS or Sass file and locates all valid import/use directive values as defined by the
- * syntax specification.
- * @param contents A string containing a CSS or Sass file to scan.
- * @returns An iterable that yields each CSS directive value found.
- */
-function* findImports(contents) {
-    yield* find(contents, '@import ');
-    yield* find(contents, '@use ');
-}
-exports.findImports = findImports;
-/**
- * Scans a CSS or Sass file and locates all valid function/directive values as defined by the
- * syntax specification.
- * @param contents A string containing a CSS or Sass file to scan.
- * @param prefix The prefix to start a valid segment.
- * @returns An iterable that yields each CSS url function value found.
- */
-function* find(contents, prefix) {
-    let pos = 0;
-    let width = 1;
-    let current = -1;
-    const next = () => {
-        pos += width;
-        current = contents.codePointAt(pos) ?? -1;
-        width = current > 0xffff ? 2 : 1;
-        return current;
-    };
-    // Based on https://www.w3.org/TR/css-syntax-3/#consume-ident-like-token
-    while ((pos = contents.indexOf(prefix, pos)) !== -1) {
-        // Set to position of the last character in prefix
-        pos += prefix.length - 1;
-        width = 1;
-        // Consume all leading whitespace
-        while (isWhitespace(next())) {
-            /* empty */
-        }
-        // Initialize URL state
-        const url = { start: pos, end: -1, specifier: '' };
-        let complete = false;
-        // If " or ', then consume the value as a string
-        if (current === 0x0022 || current === 0x0027) {
-            const ending = current;
-            // Based on https://www.w3.org/TR/css-syntax-3/#consume-string-token
-            while (!complete) {
-                switch (next()) {
-                    case -1: // EOF
-                        return;
-                    case 0x000a: // line feed
-                    case 0x000c: // form feed
-                    case 0x000d: // carriage return
-                        // Invalid
-                        complete = true;
-                        break;
-                    case 0x005c: // \ -- character escape
-                        // If not EOF or newline, add the character after the escape
-                        switch (next()) {
-                            case -1:
-                                return;
-                            case 0x000a: // line feed
-                            case 0x000c: // form feed
-                            case 0x000d: // carriage return
-                                // Skip when inside a string
-                                break;
-                            default:
-                                // TODO: Handle hex escape codes
-                                url.specifier += String.fromCodePoint(current);
-                                break;
-                        }
-                        break;
-                    case ending:
-                        // Full string position should include the quotes for replacement
-                        url.end = pos + 1;
-                        complete = true;
-                        yield url;
-                        break;
-                    default:
-                        url.specifier += String.fromCodePoint(current);
-                        break;
-                }
-            }
-            next();
-            continue;
-        }
-    }
-}

package/src/{builders/jest → utils}/test-files.d.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import fastGlob from 'fast-glob';
-import { JestBuilderOptions } from './options';
 /**
  * Finds all test files in the project.
  *
@@ -16,4 +15,4 @@ import { JestBuilderOptions } from './options';
  *     testing purposes.
  * @returns A set of all test files in the project.
  */
-export declare function findTestFiles(options: JestBuilderOptions, workspaceRoot: string, glob?: typeof fastGlob): Promise<Set<string>>;
+export declare function findTestFiles(include: string[], exclude: string[], workspaceRoot: string, glob?: typeof fastGlob): Promise<Set<string>>;

package/src/{builders/jest → utils}/test-files.js

@@ -21,14 +21,14 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
  *     testing purposes.
  * @returns A set of all test files in the project.
  */
-async function findTestFiles(options, workspaceRoot, glob = fast_glob_1.default) {
+async function findTestFiles(include, exclude, workspaceRoot, glob = fast_glob_1.default) {
     const globOptions = {
         cwd: workspaceRoot,
-        ignore: ['node_modules/**'].concat(options.exclude),
+        ignore: ['node_modules/**'].concat(exclude),
         braceExpansion: false, // Do not expand `a{b,c}` to `ab,ac`.
         extglob: false, // Disable "extglob" patterns.
     };
-    const included = await Promise.all(options.include.map((pattern) => glob(pattern, globOptions)));
+    const included = await Promise.all(include.map((pattern) => glob(pattern, globOptions)));
     // Flatten and deduplicate any files found in multiple include patterns.
     return new Set(included.flat());
 }