@angular-devkit/build-angular 17.3.0 → 18.0.0-next.0

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

@@ -1,173 +0,0 @@
-"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 {
-    workers = [];
-    availableWorkers = [];
-    requests = new Map();
-    workerPath = (0, path_1.join)(__dirname, './worker-legacy.js');
-    idCounter = 1;
-    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?.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/tools/sass/worker-legacy.d.ts

@@ -1,8 +0,0 @@
-/**
- * @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 {};

package/src/tools/sass/worker-legacy.js

@@ -1,43 +0,0 @@
-"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) {
-                Atomics.store(importerSignal, 0, 0);
-                const { fromImport } = this;
-                workerImporterPort.postMessage({ id, url, prev, fromImport });
-                Atomics.wait(importerSignal, 0, 0);
-                return (0, worker_threads_1.receiveMessageOnPort)(workerImporterPort)?.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?.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?.postMessage({ id, error: { formatted, file, line, column, message, stack } });
-    }
-});

package/src/utils/server-rendering/esm-in-memory-loader/node-18-utils.d.ts

@@ -1,10 +0,0 @@
-/**
- * @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
- */
-/** Call the initialize hook when running on Node.js 18 */
-export declare function callInitializeIfNeeded(initialize: (typeof import('./loader-hooks'))['initialize']): void;
-export declare function getESMLoaderArgs(): string[];

package/src/utils/server-rendering/esm-in-memory-loader/node-18-utils.js

@@ -1,39 +0,0 @@
-"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.getESMLoaderArgs = exports.callInitializeIfNeeded = void 0;
-const node_path_1 = require("node:path");
-const node_url_1 = require("node:url");
-const node_worker_threads_1 = require("node:worker_threads");
-const semver_1 = require("semver");
-let SUPPORTS_IMPORT_FLAG;
-function supportsImportFlag() {
-    return (SUPPORTS_IMPORT_FLAG ??= (0, semver_1.satisfies)(process.versions.node, '>= 18.19'));
-}
-/** Call the initialize hook when running on Node.js 18 */
-function callInitializeIfNeeded(initialize) {
-    if (!supportsImportFlag()) {
-        initialize(node_worker_threads_1.workerData);
-    }
-}
-exports.callInitializeIfNeeded = callInitializeIfNeeded;
-function getESMLoaderArgs() {
-    if (!supportsImportFlag()) {
-        return [
-            '--no-warnings', // Suppress `ExperimentalWarning: Custom ESM Loaders is an experimental feature...`.
-            '--loader',
-            (0, node_url_1.pathToFileURL)((0, node_path_1.join)(__dirname, 'loader-hooks.js')).href, // Loader cannot be an absolute path on Windows.
-        ];
-    }
-    return [
-        '--import',
-        (0, node_url_1.pathToFileURL)((0, node_path_1.join)(__dirname, 'register-hooks.js')).href, // Loader cannot be an absolute path on Windows.
-    ];
-}
-exports.getESMLoaderArgs = getESMLoaderArgs;