@angular-devkit/build-angular 15.0.0-next.2 → 15.0.0-next.3

package/src/sass/sass-service-legacy.js

@@ -0,0 +1,175 @@
+"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.SassLegacyWorkerImplementation = void 0;
+const path_1 = require("path");
+const worker_threads_1 = require("worker_threads");
+const environment_options_1 = require("../utils/environment-options");
+/**
+ * The maximum number of Workers that will be created to execute render requests.
+ */
+const MAX_RENDER_WORKERS = environment_options_1.maxWorkers;
+/**
+ * A Sass renderer implementation that provides an interface that can be used by Webpack's
+ * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering
+ * with the `dart-sass` package.  The `dart-sass` synchronous render function is used within
+ * the worker which can be up to two times faster than the asynchronous variant.
+ */
+class SassLegacyWorkerImplementation {
+    constructor() {
+        this.workers = [];
+        this.availableWorkers = [];
+        this.requests = new Map();
+        this.workerPath = (0, path_1.join)(__dirname, './worker-legacy.js');
+        this.idCounter = 1;
+        this.nextWorkerIndex = 0;
+    }
+    /**
+     * Provides information about the Sass implementation.
+     * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.
+     */
+    get info() {
+        return 'dart-sass\tworker';
+    }
+    /**
+     * The synchronous render function is not used by the `sass-loader`.
+     */
+    renderSync() {
+        throw new Error('Sass renderSync is not supported.');
+    }
+    /**
+     * Asynchronously request a Sass stylesheet to be renderered.
+     *
+     * @param options The `dart-sass` options to use when rendering the stylesheet.
+     * @param callback The function to execute when the rendering is complete.
+     */
+    render(options, callback) {
+        // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred.
+        // If any additional function options are added in the future, they must be excluded as well.
+        const { functions, importer, logger, ...serializableOptions } = options;
+        // The CLI's configuration does not use or expose the ability to defined custom Sass functions
+        if (functions && Object.keys(functions).length > 0) {
+            throw new Error('Sass custom functions are not supported.');
+        }
+        let workerIndex = this.availableWorkers.pop();
+        if (workerIndex === undefined) {
+            if (this.workers.length < MAX_RENDER_WORKERS) {
+                workerIndex = this.workers.length;
+                this.workers.push(this.createWorker());
+            }
+            else {
+                workerIndex = this.nextWorkerIndex++;
+                if (this.nextWorkerIndex >= this.workers.length) {
+                    this.nextWorkerIndex = 0;
+                }
+            }
+        }
+        const request = this.createRequest(workerIndex, callback, importer);
+        this.requests.set(request.id, request);
+        this.workers[workerIndex].postMessage({
+            id: request.id,
+            hasImporter: !!importer,
+            options: serializableOptions,
+        });
+    }
+    /**
+     * Shutdown the Sass render worker.
+     * Executing this method will stop any pending render requests.
+     */
+    close() {
+        for (const worker of this.workers) {
+            try {
+                void worker.terminate();
+            }
+            catch { }
+        }
+        this.requests.clear();
+    }
+    createWorker() {
+        const { port1: mainImporterPort, port2: workerImporterPort } = new worker_threads_1.MessageChannel();
+        const importerSignal = new Int32Array(new SharedArrayBuffer(4));
+        const worker = new worker_threads_1.Worker(this.workerPath, {
+            workerData: { workerImporterPort, importerSignal },
+            transferList: [workerImporterPort],
+        });
+        worker.on('message', (response) => {
+            const request = this.requests.get(response.id);
+            if (!request) {
+                return;
+            }
+            this.requests.delete(response.id);
+            this.availableWorkers.push(request.workerIndex);
+            if (response.result) {
+                // The results are expected to be Node.js `Buffer` objects but will each be transferred as
+                // a Uint8Array that does not have the expected `toString` behavior of a `Buffer`.
+                const { css, map, stats } = response.result;
+                const result = {
+                    // This `Buffer.from` override will use the memory directly and avoid making a copy
+                    css: Buffer.from(css.buffer, css.byteOffset, css.byteLength),
+                    stats,
+                };
+                if (map) {
+                    // This `Buffer.from` override will use the memory directly and avoid making a copy
+                    result.map = Buffer.from(map.buffer, map.byteOffset, map.byteLength);
+                }
+                request.callback(undefined, result);
+            }
+            else {
+                request.callback(response.error);
+            }
+        });
+        mainImporterPort.on('message', ({ id, url, prev, fromImport, }) => {
+            const request = this.requests.get(id);
+            if (!(request === null || request === void 0 ? void 0 : request.importers)) {
+                mainImporterPort.postMessage(null);
+                Atomics.store(importerSignal, 0, 1);
+                Atomics.notify(importerSignal, 0);
+                return;
+            }
+            this.processImporters(request.importers, url, prev, fromImport)
+                .then((result) => {
+                mainImporterPort.postMessage(result);
+            })
+                .catch((error) => {
+                mainImporterPort.postMessage(error);
+            })
+                .finally(() => {
+                Atomics.store(importerSignal, 0, 1);
+                Atomics.notify(importerSignal, 0);
+            });
+        });
+        mainImporterPort.unref();
+        return worker;
+    }
+    async processImporters(importers, url, prev, fromImport) {
+        let result = null;
+        for (const importer of importers) {
+            result = await new Promise((resolve) => {
+                // Importers can be both sync and async
+                const innerResult = importer.call({ fromImport }, url, prev, resolve);
+                if (innerResult !== undefined) {
+                    resolve(innerResult);
+                }
+            });
+            if (result) {
+                break;
+            }
+        }
+        return result;
+    }
+    createRequest(workerIndex, callback, importer) {
+        return {
+            id: this.idCounter++,
+            workerIndex,
+            callback,
+            importers: !importer || Array.isArray(importer) ? importer : [importer],
+        };
+    }
+}
+exports.SassLegacyWorkerImplementation = SassLegacyWorkerImplementation;

package/src/sass/sass-service.d.ts

@@ -5,11 +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 { LegacyResult as CompileResult, LegacyException as Exception, LegacyOptions as Options } from 'sass';
-/**
- * The callback type for the `dart-sass` asynchronous render function.
- */
-declare type RenderCallback = (error?: Exception, result?: CompileResult) => void;
+import { CompileResult, StringOptionsWithImporter, StringOptionsWithoutImporter } from 'sass';
 /**
  * A Sass renderer implementation that provides an interface that can be used by Webpack's
  * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering
@@ -20,6 +16,7 @@ export declare class SassWorkerImplementation {
     private readonly workers;
     private readonly availableWorkers;
     private readonly requests;
+    private readonly workerPath;
     private idCounter;
     private nextWorkerIndex;
     /**
@@ -30,14 +27,14 @@ export declare class SassWorkerImplementation {
     /**
      * The synchronous render function is not used by the `sass-loader`.
      */
-    renderSync(): never;
+    compileString(): never;
     /**
      * Asynchronously request a Sass stylesheet to be renderered.
      *
+     * @param source The contents to compile.
      * @param options The `dart-sass` options to use when rendering the stylesheet.
-     * @param callback The function to execute when the rendering is complete.
      */
-    render(options: Options<'async'>, callback: RenderCallback): void;
+    compileStringAsync(source: string, options: StringOptionsWithImporter<'async'> | StringOptionsWithoutImporter<'async'>): Promise<CompileResult>;
     /**
      * Shutdown the Sass render worker.
      * Executing this method will stop any pending render requests.
@@ -46,5 +43,5 @@ export declare class SassWorkerImplementation {
     private createWorker;
     private processImporters;
     private createRequest;
+    private isImporter;
 }
-export {};

package/src/sass/sass-service.js

@@ -8,6 +8,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SassWorkerImplementation = void 0;
+const path_1 = require("path");
+const url_1 = require("url");
 const worker_threads_1 = require("worker_threads");
 const environment_options_1 = require("../utils/environment-options");
 /**
@@ -25,6 +27,7 @@ class SassWorkerImplementation {
         this.workers = [];
         this.availableWorkers = [];
         this.requests = new Map();
+        this.workerPath = (0, path_1.join)(__dirname, './worker.js');
         this.idCounter = 1;
         this.nextWorkerIndex = 0;
     }
@@ -38,42 +41,64 @@ class SassWorkerImplementation {
     /**
      * The synchronous render function is not used by the `sass-loader`.
      */
-    renderSync() {
-        throw new Error('Sass renderSync is not supported.');
+    compileString() {
+        throw new Error('Sass compileString is not supported.');
     }
     /**
      * Asynchronously request a Sass stylesheet to be renderered.
      *
+     * @param source The contents to compile.
      * @param options The `dart-sass` options to use when rendering the stylesheet.
-     * @param callback The function to execute when the rendering is complete.
      */
-    render(options, callback) {
+    compileStringAsync(source, options) {
         // The `functions`, `logger` and `importer` options are JavaScript functions that cannot be transferred.
         // If any additional function options are added in the future, they must be excluded as well.
-        const { functions, importer, logger, ...serializableOptions } = options;
+        const { functions, importers, url, logger, ...serializableOptions } = options;
         // The CLI's configuration does not use or expose the ability to defined custom Sass functions
         if (functions && Object.keys(functions).length > 0) {
             throw new Error('Sass custom functions are not supported.');
         }
-        let workerIndex = this.availableWorkers.pop();
-        if (workerIndex === undefined) {
-            if (this.workers.length < MAX_RENDER_WORKERS) {
-                workerIndex = this.workers.length;
-                this.workers.push(this.createWorker());
-            }
-            else {
-                workerIndex = this.nextWorkerIndex++;
-                if (this.nextWorkerIndex >= this.workers.length) {
-                    this.nextWorkerIndex = 0;
+        return new Promise((resolve, reject) => {
+            let workerIndex = this.availableWorkers.pop();
+            if (workerIndex === undefined) {
+                if (this.workers.length < MAX_RENDER_WORKERS) {
+                    workerIndex = this.workers.length;
+                    this.workers.push(this.createWorker());
+                }
+                else {
+                    workerIndex = this.nextWorkerIndex++;
+                    if (this.nextWorkerIndex >= this.workers.length) {
+                        this.nextWorkerIndex = 0;
+                    }
                 }
             }
-        }
-        const request = this.createRequest(workerIndex, callback, importer);
-        this.requests.set(request.id, request);
-        this.workers[workerIndex].postMessage({
-            id: request.id,
-            hasImporter: !!importer,
-            options: serializableOptions,
+            const callback = (error, result) => {
+                if (error) {
+                    const url = error === null || error === void 0 ? void 0 : error.span.url;
+                    if (url) {
+                        error.span.url = (0, url_1.pathToFileURL)(url);
+                    }
+                    reject(error);
+                    return;
+                }
+                if (!result) {
+                    reject(new Error('No result.'));
+                    return;
+                }
+                resolve(result);
+            };
+            const request = this.createRequest(workerIndex, callback, importers);
+            this.requests.set(request.id, request);
+            this.workers[workerIndex].postMessage({
+                id: request.id,
+                source,
+                hasImporter: !!(importers === null || importers === void 0 ? void 0 : importers.length),
+                options: {
+                    ...serializableOptions,
+                    // URL is not serializable so to convert to string here and back to URL in the worker.
+                    url: url ? (0, url_1.fileURLToPath)(url) : undefined,
+                },
+            });
         });
     }
     /**
@@ -92,8 +117,7 @@ class SassWorkerImplementation {
     createWorker() {
         const { port1: mainImporterPort, port2: workerImporterPort } = new worker_threads_1.MessageChannel();
         const importerSignal = new Int32Array(new SharedArrayBuffer(4));
-        const workerPath = require.resolve('./worker');
-        const worker = new worker_threads_1.Worker(workerPath, {
+        const worker = new worker_threads_1.Worker(this.workerPath, {
             workerData: { workerImporterPort, importerSignal },
             transferList: [workerImporterPort],
         });
@@ -105,25 +129,17 @@ class SassWorkerImplementation {
             this.requests.delete(response.id);
             this.availableWorkers.push(request.workerIndex);
             if (response.result) {
-                // The results are expected to be Node.js `Buffer` objects but will each be transferred as
-                // a Uint8Array that does not have the expected `toString` behavior of a `Buffer`.
-                const { css, map, stats } = response.result;
-                const result = {
-                    // This `Buffer.from` override will use the memory directly and avoid making a copy
-                    css: Buffer.from(css.buffer, css.byteOffset, css.byteLength),
-                    stats,
-                };
-                if (map) {
-                    // This `Buffer.from` override will use the memory directly and avoid making a copy
-                    result.map = Buffer.from(map.buffer, map.byteOffset, map.byteLength);
-                }
-                request.callback(undefined, result);
+                request.callback(undefined, {
+                    ...response.result,
+                    // URL is not serializable so in the worker we convert to string and here back to URL.
+                    loadedUrls: response.result.loadedUrls.map((p) => (0, url_1.pathToFileURL)(p)),
+                });
             }
             else {
                 request.callback(response.error);
             }
         });
-        mainImporterPort.on('message', ({ id, url, prev, fromImport, }) => {
+        mainImporterPort.on('message', ({ id, url, options }) => {
             const request = this.requests.get(id);
             if (!(request === null || request === void 0 ? void 0 : request.importers)) {
                 mainImporterPort.postMessage(null);
@@ -131,7 +147,7 @@ class SassWorkerImplementation {
                 Atomics.notify(importerSignal, 0);
                 return;
             }
-            this.processImporters(request.importers, url, prev, fromImport)
+            this.processImporters(request.importers, url, options)
                 .then((result) => {
                 mainImporterPort.postMessage(result);
             })
@@ -146,29 +162,30 @@ class SassWorkerImplementation {
         mainImporterPort.unref();
         return worker;
     }
-    async processImporters(importers, url, prev, fromImport) {
-        let result = null;
+    async processImporters(importers, url, options) {
         for (const importer of importers) {
-            result = await new Promise((resolve) => {
-                // Importers can be both sync and async
-                const innerResult = importer.call({ fromImport }, url, prev, resolve);
-                if (innerResult !== undefined) {
-                    resolve(innerResult);
-                }
-            });
+            if (this.isImporter(importer)) {
+                // Importer
+                throw new Error('Only File Importers are supported.');
+            }
+            // File importer (Can be sync or aync).
+            const result = await importer.findFileUrl(url, options);
             if (result) {
-                break;
+                return (0, url_1.fileURLToPath)(result);
             }
         }
-        return result;
+        return null;
     }
-    createRequest(workerIndex, callback, importer) {
+    createRequest(workerIndex, callback, importers) {
         return {
             id: this.idCounter++,
             workerIndex,
             callback,
-            importers: !importer || Array.isArray(importer) ? importer : [importer],
+            importers,
         };
     }
+    isImporter(value) {
+        return 'canonicalize' in value && 'load' in value;
+    }
 }
 exports.SassWorkerImplementation = SassWorkerImplementation;

package/src/{builders/karma/find-tests.d.ts → sass/worker-legacy.d.ts}

@@ -5,4 +5,4 @@
  * 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 function findTests(patterns: string[], workspaceRoot: string, projectSourceRoot: string): Promise<string[]>;
+export {};

package/src/sass/worker-legacy.js

@@ -0,0 +1,44 @@
+"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 });
+const sass_1 = require("sass");
+const worker_threads_1 = require("worker_threads");
+if (!worker_threads_1.parentPort || !worker_threads_1.workerData) {
+    throw new Error('Sass worker must be executed as a Worker.');
+}
+// The importer variables are used to proxy import requests to the main thread
+const { workerImporterPort, importerSignal } = worker_threads_1.workerData;
+worker_threads_1.parentPort.on('message', ({ id, hasImporter, options }) => {
+    try {
+        if (hasImporter) {
+            // When a custom importer function is present, the importer request must be proxied
+            // back to the main thread where it can be executed.
+            // This process must be synchronous from the perspective of dart-sass. The `Atomics`
+            // functions combined with the shared memory `importSignal` and the Node.js
+            // `receiveMessageOnPort` function are used to ensure synchronous behavior.
+            options.importer = function (url, prev) {
+                var _a;
+                Atomics.store(importerSignal, 0, 0);
+                const { fromImport } = this;
+                workerImporterPort.postMessage({ id, url, prev, fromImport });
+                Atomics.wait(importerSignal, 0, 0);
+                return (_a = (0, worker_threads_1.receiveMessageOnPort)(workerImporterPort)) === null || _a === void 0 ? void 0 : _a.message;
+            };
+        }
+        // The synchronous Sass render function can be up to two times faster than the async variant
+        const result = (0, sass_1.renderSync)(options);
+        worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({ id, result });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (error) {
+        // Needed because V8 will only serialize the message and stack properties of an Error instance.
+        const { formatted, file, line, column, message, stack } = error;
+        worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({ id, error: { formatted, file, line, column, message, stack } });
+    }
+});

package/src/sass/worker.js

@@ -8,13 +8,17 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const sass_1 = require("sass");
+const url_1 = require("url");
 const worker_threads_1 = require("worker_threads");
 if (!worker_threads_1.parentPort || !worker_threads_1.workerData) {
     throw new Error('Sass worker must be executed as a Worker.');
 }
 // The importer variables are used to proxy import requests to the main thread
 const { workerImporterPort, importerSignal } = worker_threads_1.workerData;
-worker_threads_1.parentPort.on('message', ({ id, hasImporter, options }) => {
+worker_threads_1.parentPort.on('message', ({ id, hasImporter, source, options }) => {
+    if (!worker_threads_1.parentPort) {
+        throw new Error('"parentPort" is not defined. Sass worker must be executed as a Worker.');
+    }
     try {
         if (hasImporter) {
             // When a custom importer function is present, the importer request must be proxied
@@ -22,23 +26,69 @@ worker_threads_1.parentPort.on('message', ({ id, hasImporter, options }) => {
             // This process must be synchronous from the perspective of dart-sass. The `Atomics`
             // functions combined with the shared memory `importSignal` and the Node.js
             // `receiveMessageOnPort` function are used to ensure synchronous behavior.
-            options.importer = function (url, prev) {
-                var _a;
-                Atomics.store(importerSignal, 0, 0);
-                const { fromImport } = this;
-                workerImporterPort.postMessage({ id, url, prev, fromImport });
-                Atomics.wait(importerSignal, 0, 0);
-                return (_a = (0, worker_threads_1.receiveMessageOnPort)(workerImporterPort)) === null || _a === void 0 ? void 0 : _a.message;
-            };
+            options.importers = [
+                {
+                    findFileUrl: (url, options) => {
+                        var _a;
+                        Atomics.store(importerSignal, 0, 0);
+                        workerImporterPort.postMessage({ id, url, options });
+                        Atomics.wait(importerSignal, 0, 0);
+                        const result = (_a = (0, worker_threads_1.receiveMessageOnPort)(workerImporterPort)) === null || _a === void 0 ? void 0 : _a.message;
+                        return result ? (0, url_1.pathToFileURL)(result) : null;
+                    },
+                },
+            ];
         }
         // The synchronous Sass render function can be up to two times faster than the async variant
-        const result = (0, sass_1.renderSync)(options);
-        worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({ id, result });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result = (0, sass_1.compileString)(source, {
+            ...options,
+            // URL is not serializable so to convert to string in the parent and back to URL here.
+            url: options.url ? (0, url_1.pathToFileURL)(options.url) : undefined,
+        });
+        worker_threads_1.parentPort.postMessage({
+            id,
+            result: {
+                ...result,
+                // URL is not serializable so to convert to string here and back to URL in the parent.
+                loadedUrls: result.loadedUrls.map((p) => (0, url_1.fileURLToPath)(p)),
+            },
+        });
     }
     catch (error) {
         // Needed because V8 will only serialize the message and stack properties of an Error instance.
-        const { formatted, file, line, column, message, stack } = error;
-        worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.postMessage({ id, error: { formatted, file, line, column, message, stack } });
+        if (error instanceof sass_1.Exception) {
+            const { span, message, stack, sassMessage, sassStack } = error;
+            worker_threads_1.parentPort.postMessage({
+                id,
+                error: {
+                    span: {
+                        text: span.text,
+                        context: span.context,
+                        end: {
+                            column: span.end.column,
+                            offset: span.end.offset,
+                            line: span.end.line,
+                        },
+                        start: {
+                            column: span.start.column,
+                            offset: span.start.offset,
+                            line: span.start.line,
+                        },
+                        url: span.url ? (0, url_1.fileURLToPath)(span.url) : undefined,
+                    },
+                    message,
+                    stack,
+                    sassMessage,
+                    sassStack,
+                },
+            });
+        }
+        else if (error instanceof Error) {
+            const { message, stack } = error;
+            worker_threads_1.parentPort.postMessage({ id, error: { message, stack } });
+        }
+        else {
+            worker_threads_1.parentPort.postMessage({ id, error: { message: 'An unknown error has occurred.' } });
+        }
     }
 });

package/src/utils/build-options.d.ts

@@ -27,7 +27,6 @@ export interface BuildOptions {
     progress?: boolean;
     localize?: Localize;
     i18nMissingTranslation?: I18NTranslation;
-    bundleDependencies?: boolean;
     externalDependencies?: string[];
     watch?: boolean;
     outputHashing?: OutputHashing;
@@ -45,7 +44,7 @@ export interface BuildOptions {
     statsJson: boolean;
     hmr?: boolean;
     main: string;
-    polyfills?: string;
+    polyfills: string[];
     budgets: Budget[];
     assets: AssetPatternClass[];
     scripts: ScriptElement[];

package/src/utils/environment-options.d.ts

@@ -9,3 +9,4 @@ export declare const allowMangle: boolean;
 export declare const shouldBeautify: boolean;
 export declare const allowMinify: boolean;
 export declare const maxWorkers: number;
+export declare const useLegacySass: boolean;

package/src/utils/environment-options.js

@@ -7,7 +7,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0;
+exports.useLegacySass = exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0;
+const color_1 = require("./color");
 function isDisabled(variable) {
     return variable === '0' || variable.toLowerCase() === 'false';
 }
@@ -67,3 +68,12 @@ exports.allowMinify = debugOptimize.minify;
  */
 const maxWorkersVariable = process.env['NG_BUILD_MAX_WORKERS'];
 exports.maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : 4;
+const legacySassVariable = process.env['NG_BUILD_LEGACY_SASS'];
+exports.useLegacySass = (() => {
+    if (!isPresent(legacySassVariable)) {
+        return false;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(color_1.colors.yellow(`Warning: 'NG_BUILD_LEGACY_SASS' environment variable support will be removed in version 16.`));
+    return isEnabled(legacySassVariable);
+})();

package/src/utils/normalize-builder-schema.d.ts

@@ -18,5 +18,6 @@ export declare type NormalizedBrowserBuilderSchema = BrowserBuilderSchema & Buil
     assets: AssetPatternClass[];
     fileReplacements: NormalizedFileReplacement[];
     optimization: NormalizedOptimizationOptions;
+    polyfills: string[];
 };
 export declare function normalizeBrowserSchema(workspaceRoot: string, projectRoot: string, projectSourceRoot: string | undefined, options: BrowserBuilderSchema, metadata: json.JsonObject, logger: logging.LoggerApi): NormalizedBrowserBuilderSchema;

package/src/utils/normalize-builder-schema.js

@@ -12,17 +12,18 @@ const normalize_asset_patterns_1 = require("./normalize-asset-patterns");
 const normalize_cache_1 = require("./normalize-cache");
 const normalize_file_replacements_1 = require("./normalize-file-replacements");
 const normalize_optimization_1 = require("./normalize-optimization");
+const normalize_polyfills_1 = require("./normalize-polyfills");
 const normalize_source_maps_1 = require("./normalize-source-maps");
 const supported_browsers_1 = require("./supported-browsers");
 function normalizeBrowserSchema(workspaceRoot, projectRoot, projectSourceRoot, options, metadata, logger) {
-    const normalizedSourceMapOptions = (0, normalize_source_maps_1.normalizeSourceMaps)(options.sourceMap || false);
     return {
         ...options,
         cache: (0, normalize_cache_1.normalizeCacheOptions)(metadata, workspaceRoot),
         assets: (0, normalize_asset_patterns_1.normalizeAssetPatterns)(options.assets || [], workspaceRoot, projectRoot, projectSourceRoot),
         fileReplacements: (0, normalize_file_replacements_1.normalizeFileReplacements)(options.fileReplacements || [], workspaceRoot),
         optimization: (0, normalize_optimization_1.normalizeOptimization)(options.optimization),
-        sourceMap: normalizedSourceMapOptions,
+        sourceMap: (0, normalize_source_maps_1.normalizeSourceMaps)(options.sourceMap || false),
+        polyfills: (0, normalize_polyfills_1.normalizePolyfills)(options.polyfills, workspaceRoot),
         preserveSymlinks: options.preserveSymlinks === undefined
             ? process.execArgv.includes('--preserve-symlinks')
             : options.preserveSymlinks,

package/src/utils/normalize-polyfills.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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 function normalizePolyfills(polyfills: string[] | string | undefined, root: string): string[];