@angular-devkit/build-angular 16.1.0-next.1 → 16.1.0-rc.0

package/src/builders/browser-esbuild/stylesheets/sass-language.js

@@ -0,0 +1,169 @@
+"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.SassStylesheetLanguage = exports.shutdownSassWorkerPool = void 0;
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+let sassWorkerPool;
+function isSassException(error) {
+    return !!error && typeof error === 'object' && 'sassMessage' in error;
+}
+function shutdownSassWorkerPool() {
+    sassWorkerPool?.close();
+    sassWorkerPool = undefined;
+}
+exports.shutdownSassWorkerPool = shutdownSassWorkerPool;
+exports.SassStylesheetLanguage = Object.freeze({
+    name: 'sass',
+    componentFilter: /^s[ac]ss;/,
+    fileFilter: /\.s[ac]ss$/,
+    process(data, file, format, options, build) {
+        const syntax = format === 'sass' ? 'indented' : 'scss';
+        const resolveUrl = async (url, previousResolvedModules) => {
+            let result = await build.resolve(url, {
+                kind: 'import-rule',
+                // This should ideally be the directory of the importer file from Sass
+                // but that is not currently available from the Sass importer API.
+                resolveDir: build.initialOptions.absWorkingDir,
+            });
+            // Workaround to support Yarn PnP without access to the importer file from Sass
+            if (!result.path && previousResolvedModules?.size) {
+                for (const previous of previousResolvedModules) {
+                    result = await build.resolve(url, {
+                        kind: 'import-rule',
+                        resolveDir: previous,
+                    });
+                    if (result.path) {
+                        break;
+                    }
+                }
+            }
+            return result;
+        };
+        return compileString(data, file, syntax, options, resolveUrl);
+    },
+});
+async function compileString(data, filePath, syntax, options, resolveUrl) {
+    // Lazily load Sass when a Sass file is found
+    if (sassWorkerPool === undefined) {
+        const sassService = await Promise.resolve().then(() => __importStar(require('../../../sass/sass-service')));
+        sassWorkerPool = new sassService.SassWorkerImplementation(true);
+    }
+    const warnings = [];
+    try {
+        const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {
+            url: (0, node_url_1.pathToFileURL)(filePath),
+            style: 'expanded',
+            syntax,
+            loadPaths: options.includePaths,
+            sourceMap: options.sourcemap,
+            sourceMapIncludeSources: options.sourcemap,
+            quietDeps: true,
+            importers: [
+                {
+                    findFileUrl: async (url, { previousResolvedModules }) => {
+                        let result = await resolveUrl(url);
+                        if (result.path) {
+                            return (0, node_url_1.pathToFileURL)(result.path);
+                        }
+                        // Check for package deep imports
+                        const parts = url.split('/');
+                        const hasScope = parts.length >= 2 && parts[0].startsWith('@');
+                        const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;
+                        const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;
+                        let packageResult = await resolveUrl(packageName + '/package.json');
+                        if (packageResult.path) {
+                            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart));
+                        }
+                        // Check with Yarn PnP workaround using previous resolved modules.
+                        // This is done last to avoid a performance penalty for common cases.
+                        result = await resolveUrl(url, previousResolvedModules);
+                        if (result.path) {
+                            return (0, node_url_1.pathToFileURL)(result.path);
+                        }
+                        packageResult = await resolveUrl(packageName + '/package.json', previousResolvedModules);
+                        if (packageResult.path) {
+                            return (0, node_url_1.pathToFileURL)((0, node_path_1.join)((0, node_path_1.dirname)(packageResult.path), !hasScope && nameOrFirstPath ? nameOrFirstPath : '', ...pathPart));
+                        }
+                        // Not found
+                        return null;
+                    },
+                },
+            ],
+            logger: {
+                warn: (text, { deprecation, span }) => {
+                    warnings.push({
+                        text: deprecation ? 'Deprecation' : text,
+                        location: span && {
+                            file: span.url && (0, node_url_1.fileURLToPath)(span.url),
+                            lineText: span.context,
+                            // Sass line numbers are 0-based while esbuild's are 1-based
+                            line: span.start.line + 1,
+                            column: span.start.column,
+                        },
+                        notes: deprecation ? [{ text }] : undefined,
+                    });
+                },
+            },
+        });
+        return {
+            loader: 'css',
+            contents: sourceMap ? `${css}\n${sourceMapToUrlComment(sourceMap, (0, node_path_1.dirname)(filePath))}` : css,
+            watchFiles: loadedUrls.map((url) => (0, node_url_1.fileURLToPath)(url)),
+            warnings,
+        };
+    }
+    catch (error) {
+        if (isSassException(error)) {
+            const file = error.span.url ? (0, node_url_1.fileURLToPath)(error.span.url) : undefined;
+            return {
+                loader: 'css',
+                errors: [
+                    {
+                        text: error.message,
+                    },
+                ],
+                warnings,
+                watchFiles: file ? [file] : undefined,
+            };
+        }
+        throw error;
+    }
+}
+function sourceMapToUrlComment(sourceMap, root) {
+    // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file.
+    // This allows esbuild to correctly process the paths.
+    sourceMap.sources = sourceMap.sources.map((source) => (0, node_path_1.relative)(root, (0, node_url_1.fileURLToPath)(source)));
+    const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');
+    return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sass-language.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/sass-language.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport type { OnLoadResult, PartialMessage, ResolveResult } from 'esbuild';\nimport { dirname, join, relative } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { CompileResult, Exception, Syntax } from 'sass';\nimport type {\n  FileImporterWithRequestContextOptions,\n  SassWorkerImplementation,\n} from '../../../sass/sass-service';\nimport { StylesheetLanguage, StylesheetPluginOptions } from './stylesheet-plugin-factory';\n\nlet sassWorkerPool: SassWorkerImplementation | undefined;\n\nfunction isSassException(error: unknown): error is Exception {\n  return !!error && typeof error === 'object' && 'sassMessage' in error;\n}\n\nexport function shutdownSassWorkerPool(): void {\n  sassWorkerPool?.close();\n  sassWorkerPool = undefined;\n}\n\nexport const SassStylesheetLanguage = Object.freeze<StylesheetLanguage>({\n  name: 'sass',\n  componentFilter: /^s[ac]ss;/,\n  fileFilter: /\\.s[ac]ss$/,\n  process(data, file, format, options, build) {\n    const syntax = format === 'sass' ? 'indented' : 'scss';\n    const resolveUrl = async (url: string, previousResolvedModules?: Set<string>) => {\n      let result = await build.resolve(url, {\n        kind: 'import-rule',\n        // This should ideally be the directory of the importer file from Sass\n        // but that is not currently available from the Sass importer API.\n        resolveDir: build.initialOptions.absWorkingDir,\n      });\n\n      // Workaround to support Yarn PnP without access to the importer file from Sass\n      if (!result.path && previousResolvedModules?.size) {\n        for (const previous of previousResolvedModules) {\n          result = await build.resolve(url, {\n            kind: 'import-rule',\n            resolveDir: previous,\n          });\n          if (result.path) {\n            break;\n          }\n        }\n      }\n\n      return result;\n    };\n\n    return compileString(data, file, syntax, options, resolveUrl);\n  },\n});\n\nasync function compileString(\n  data: string,\n  filePath: string,\n  syntax: Syntax,\n  options: StylesheetPluginOptions,\n  resolveUrl: (url: string, previousResolvedModules?: Set<string>) => Promise<ResolveResult>,\n): Promise<OnLoadResult> {\n  // Lazily load Sass when a Sass file is found\n  if (sassWorkerPool === undefined) {\n    const sassService = await import('../../../sass/sass-service');\n    sassWorkerPool = new sassService.SassWorkerImplementation(true);\n  }\n\n  const warnings: PartialMessage[] = [];\n  try {\n    const { css, sourceMap, loadedUrls } = await sassWorkerPool.compileStringAsync(data, {\n      url: pathToFileURL(filePath),\n      style: 'expanded',\n      syntax,\n      loadPaths: options.includePaths,\n      sourceMap: options.sourcemap,\n      sourceMapIncludeSources: options.sourcemap,\n      quietDeps: true,\n      importers: [\n        {\n          findFileUrl: async (\n            url,\n            { previousResolvedModules }: FileImporterWithRequestContextOptions,\n          ): Promise<URL | null> => {\n            let result = await resolveUrl(url);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            // Check for package deep imports\n            const parts = url.split('/');\n            const hasScope = parts.length >= 2 && parts[0].startsWith('@');\n            const [nameOrScope, nameOrFirstPath, ...pathPart] = parts;\n            const packageName = hasScope ? `${nameOrScope}/${nameOrFirstPath}` : nameOrScope;\n\n            let packageResult = await resolveUrl(packageName + '/package.json');\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Check with Yarn PnP workaround using previous resolved modules.\n            // This is done last to avoid a performance penalty for common cases.\n\n            result = await resolveUrl(url, previousResolvedModules);\n            if (result.path) {\n              return pathToFileURL(result.path);\n            }\n\n            packageResult = await resolveUrl(\n              packageName + '/package.json',\n              previousResolvedModules,\n            );\n\n            if (packageResult.path) {\n              return pathToFileURL(\n                join(\n                  dirname(packageResult.path),\n                  !hasScope && nameOrFirstPath ? nameOrFirstPath : '',\n                  ...pathPart,\n                ),\n              );\n            }\n\n            // Not found\n            return null;\n          },\n        },\n      ],\n      logger: {\n        warn: (text, { deprecation, span }) => {\n          warnings.push({\n            text: deprecation ? 'Deprecation' : text,\n            location: span && {\n              file: span.url && fileURLToPath(span.url),\n              lineText: span.context,\n              // Sass line numbers are 0-based while esbuild's are 1-based\n              line: span.start.line + 1,\n              column: span.start.column,\n            },\n            notes: deprecation ? [{ text }] : undefined,\n          });\n        },\n      },\n    });\n\n    return {\n      loader: 'css',\n      contents: sourceMap ? `${css}\\n${sourceMapToUrlComment(sourceMap, dirname(filePath))}` : css,\n      watchFiles: loadedUrls.map((url) => fileURLToPath(url)),\n      warnings,\n    };\n  } catch (error) {\n    if (isSassException(error)) {\n      const file = error.span.url ? fileURLToPath(error.span.url) : undefined;\n\n      return {\n        loader: 'css',\n        errors: [\n          {\n            text: error.message,\n          },\n        ],\n        warnings,\n        watchFiles: file ? [file] : undefined,\n      };\n    }\n\n    throw error;\n  }\n}\n\nfunction sourceMapToUrlComment(\n  sourceMap: Exclude<CompileResult['sourceMap'], undefined>,\n  root: string,\n): string {\n  // Remove `file` protocol from all sourcemap sources and adjust to be relative to the input file.\n  // This allows esbuild to correctly process the paths.\n  sourceMap.sources = sourceMap.sources.map((source) => relative(root, fileURLToPath(source)));\n\n  const urlSourceMap = Buffer.from(JSON.stringify(sourceMap), 'utf-8').toString('base64');\n\n  return `/*# sourceMappingURL=data:application/json;charset=utf-8;base64,${urlSourceMap} */`;\n}\n"]}

package/src/builders/browser-esbuild/stylesheets/{css-plugin.d.ts → stylesheet-plugin-factory.d.ts}

@@ -5,17 +5,18 @@
  * 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 { Plugin } from 'esbuild';
+import type { OnLoadResult, Plugin, PluginBuild } from 'esbuild';
 import { LoadResultCache } from '../load-result-cache';
 /**
- * An object containing the plugin options to use when processing CSS stylesheets.
+ * An object containing the plugin options to use when processing stylesheets.
  */
-export interface CssPluginOptions {
+export interface StylesheetPluginOptions {
     /**
      * Controls the use and creation of sourcemaps when processing the stylesheets.
      * If true, sourcemap processing is enabled; if false, disabled.
      */
     sourcemap: boolean;
+    includePaths?: string[];
     /**
      * Optional component data for any inline styles from Component decorator `styles` fields.
      * The key is an internal angular resource URI and the value is the stylesheet content.
@@ -32,9 +33,16 @@ export interface CssPluginOptions {
         package: string;
     };
 }
-/**
- * Creates an esbuild plugin to process CSS stylesheets.
- * @param options An object containing the plugin options.
- * @returns An esbuild Plugin instance.
- */
-export declare function createCssPlugin(options: CssPluginOptions, cache?: LoadResultCache): Plugin;
+export interface StylesheetLanguage {
+    name: string;
+    componentFilter: RegExp;
+    fileFilter: RegExp;
+    process?(data: string, file: string, format: string, options: StylesheetPluginOptions, build: PluginBuild): OnLoadResult | Promise<OnLoadResult>;
+}
+export declare class StylesheetPluginFactory {
+    private readonly options;
+    private readonly cache?;
+    private autoprefixer;
+    constructor(options: StylesheetPluginOptions, cache?: LoadResultCache | undefined);
+    create(language: Readonly<StylesheetLanguage>): Plugin;
+}

package/src/builders/browser-esbuild/stylesheets/stylesheet-plugin-factory.js

@@ -0,0 +1,218 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylesheetPluginFactory = void 0;
+const autoprefixer_1 = __importDefault(require("autoprefixer"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const load_result_cache_1 = require("../load-result-cache");
+/**
+ * The lazy-loaded instance of the postcss stylesheet postprocessor.
+ * It is only imported and initialized if postcss is needed.
+ */
+let postcss;
+class StylesheetPluginFactory {
+    constructor(options, cache) {
+        this.options = options;
+        this.cache = cache;
+        const autoprefixer = (0, autoprefixer_1.default)({
+            overrideBrowserslist: options.browsers,
+            ignoreUnknownVersions: true,
+        });
+        // Autoprefixer currently does not contain a method to check if autoprefixer is required
+        // based on the provided list of browsers. However, it does contain a method that returns
+        // informational text that can be used as a replacement. The text "Awesome!" will be present
+        // when autoprefixer determines no actions are needed.
+        // ref: https://github.com/postcss/autoprefixer/blob/e2f5c26ff1f3eaca95a21873723ce1cdf6e59f0e/lib/info.js#L118
+        const autoprefixerInfo = autoprefixer.info();
+        const skipAutoprefixer = autoprefixerInfo.includes('Awesome!');
+        if (!skipAutoprefixer) {
+            this.autoprefixer = autoprefixer;
+        }
+    }
+    create(language) {
+        // Return a noop plugin if no load actions are required
+        if (!language.process && !this.autoprefixer && !this.options.tailwindConfiguration) {
+            return {
+                name: 'angular-' + language.name,
+                setup() { },
+            };
+        }
+        const { autoprefixer, cache, options } = this;
+        return {
+            name: 'angular-' + language.name,
+            async setup(build) {
+                // Setup postcss if needed by either autoprefixer or tailwind
+                // TODO: Move this into the plugin factory to avoid repeat setup per created plugin
+                let postcssProcessor;
+                if (autoprefixer || options.tailwindConfiguration) {
+                    postcss ?? (postcss = (await Promise.resolve().then(() => __importStar(require('postcss')))).default);
+                    postcssProcessor = postcss();
+                    if (options.tailwindConfiguration) {
+                        const tailwind = await Promise.resolve(`${options.tailwindConfiguration.package}`).then(s => __importStar(require(s)));
+                        postcssProcessor.use(tailwind.default({ config: options.tailwindConfiguration.file }));
+                    }
+                    if (autoprefixer) {
+                        postcssProcessor.use(autoprefixer);
+                    }
+                }
+                // Add a load callback to support inline Component styles
+                build.onLoad({ filter: language.componentFilter, namespace: 'angular:styles/component' }, (0, load_result_cache_1.createCachedLoad)(cache, async (args) => {
+                    const data = options.inlineComponentData?.[args.path];
+                    (0, node_assert_1.default)(typeof data === 'string', `component style name should always be found [${args.path}]`);
+                    const [format, , filename] = args.path.split(';', 3);
+                    return processStylesheet(language, data, filename, format, options, build, postcssProcessor);
+                }));
+                // Add a load callback to support files from disk
+                build.onLoad({ filter: language.fileFilter }, (0, load_result_cache_1.createCachedLoad)(cache, async (args) => {
+                    const data = await (0, promises_1.readFile)(args.path, 'utf-8');
+                    return processStylesheet(language, data, args.path, (0, node_path_1.extname)(args.path).toLowerCase().slice(1), options, build, postcssProcessor);
+                }));
+            },
+        };
+    }
+}
+exports.StylesheetPluginFactory = StylesheetPluginFactory;
+async function processStylesheet(language, data, filename, format, options, build, postcssProcessor) {
+    let result;
+    // Process the input data if the language requires preprocessing
+    if (language.process) {
+        result = await language.process(data, filename, format, options, build);
+    }
+    else {
+        result = {
+            contents: data,
+            loader: 'css',
+            watchFiles: [filename],
+        };
+    }
+    // Transform with postcss if needed and there are no errors
+    if (postcssProcessor && result.contents && !result.errors?.length) {
+        const postcssResult = await compileString(typeof result.contents === 'string'
+            ? result.contents
+            : Buffer.from(result.contents).toString('utf-8'), filename, postcssProcessor, options);
+        // Merge results
+        if (postcssResult.errors?.length) {
+            delete result.contents;
+        }
+        if (result.warnings && postcssResult.warnings) {
+            postcssResult.warnings.unshift(...result.warnings);
+        }
+        if (result.watchFiles && postcssResult.watchFiles) {
+            postcssResult.watchFiles.unshift(...result.watchFiles);
+        }
+        if (result.watchDirs && postcssResult.watchDirs) {
+            postcssResult.watchDirs.unshift(...result.watchDirs);
+        }
+        result = {
+            ...result,
+            ...postcssResult,
+        };
+    }
+    return result;
+}
+/**
+ * Compiles the provided CSS stylesheet data using a provided postcss processor and provides an
+ * esbuild load result that can be used directly by an esbuild Plugin.
+ * @param data The stylesheet content to process.
+ * @param filename The name of the file that contains the data.
+ * @param postcssProcessor A postcss processor instance to use.
+ * @param options The plugin options to control the processing.
+ * @returns An esbuild OnLoaderResult object with the processed content, warnings, and/or errors.
+ */
+async function compileString(data, filename, postcssProcessor, options) {
+    try {
+        const result = await postcssProcessor.process(data, {
+            from: filename,
+            to: filename,
+            map: options.sourcemap && {
+                inline: true,
+                sourcesContent: true,
+            },
+        });
+        const rawWarnings = result.warnings();
+        let warnings;
+        if (rawWarnings.length > 0) {
+            const lineMappings = new Map();
+            warnings = rawWarnings.map((warning) => {
+                const file = warning.node.source?.input.file;
+                if (file === undefined) {
+                    return { text: warning.text };
+                }
+                let lines = lineMappings.get(file);
+                if (lines === undefined) {
+                    lines = warning.node.source?.input.css.split(/\r?\n/);
+                    lineMappings.set(file, lines ?? null);
+                }
+                return {
+                    text: warning.text,
+                    location: {
+                        file,
+                        line: warning.line,
+                        column: warning.column - 1,
+                        lineText: lines?.[warning.line - 1],
+                    },
+                };
+            });
+        }
+        return {
+            contents: result.css,
+            loader: 'css',
+            warnings,
+        };
+    }
+    catch (error) {
+        postcss ?? (postcss = (await Promise.resolve().then(() => __importStar(require('postcss')))).default);
+        if (error instanceof postcss.CssSyntaxError) {
+            const lines = error.source?.split(/\r?\n/);
+            return {
+                errors: [
+                    {
+                        text: error.reason,
+                        location: {
+                            file: error.file,
+                            line: error.line,
+                            column: error.column && error.column - 1,
+                            lineText: error.line === undefined ? undefined : lines?.[error.line - 1],
+                        },
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stylesheet-plugin-factory.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/builders/browser-esbuild/stylesheets/stylesheet-plugin-factory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport createAutoPrefixerPlugin from 'autoprefixer';\nimport type { OnLoadResult, Plugin, PluginBuild } from 'esbuild';\nimport assert from 'node:assert';\nimport { readFile } from 'node:fs/promises';\nimport { extname } from 'node:path';\nimport { LoadResultCache, createCachedLoad } from '../load-result-cache';\n\n/**\n * The lazy-loaded instance of the postcss stylesheet postprocessor.\n * It is only imported and initialized if postcss is needed.\n */\nlet postcss: typeof import('postcss')['default'] | undefined;\n\n/**\n * An object containing the plugin options to use when processing stylesheets.\n */\nexport interface StylesheetPluginOptions {\n  /**\n   * Controls the use and creation of sourcemaps when processing the stylesheets.\n   * If true, sourcemap processing is enabled; if false, disabled.\n   */\n  sourcemap: boolean;\n\n  includePaths?: string[];\n\n  /**\n   * Optional component data for any inline styles from Component decorator `styles` fields.\n   * The key is an internal angular resource URI and the value is the stylesheet content.\n   */\n  inlineComponentData?: Record<string, string>;\n\n  /**\n   * The browsers to support in browserslist format when processing stylesheets.\n   * Some postcss plugins such as autoprefixer require the raw browserslist information instead\n   * of the esbuild formatted target.\n   */\n  browsers: string[];\n\n  tailwindConfiguration?: { file: string; package: string };\n}\n\nexport interface StylesheetLanguage {\n  name: string;\n  componentFilter: RegExp;\n  fileFilter: RegExp;\n  process?(\n    data: string,\n    file: string,\n    format: string,\n    options: StylesheetPluginOptions,\n    build: PluginBuild,\n  ): OnLoadResult | Promise<OnLoadResult>;\n}\n\nexport class StylesheetPluginFactory {\n  private autoprefixer: import('postcss').Plugin | undefined;\n\n  constructor(\n    private readonly options: StylesheetPluginOptions,\n    private readonly cache?: LoadResultCache,\n  ) {\n    const autoprefixer = createAutoPrefixerPlugin({\n      overrideBrowserslist: options.browsers,\n      ignoreUnknownVersions: true,\n    });\n\n    // Autoprefixer currently does not contain a method to check if autoprefixer is required\n    // based on the provided list of browsers. However, it does contain a method that returns\n    // informational text that can be used as a replacement. The text \"Awesome!\" will be present\n    // when autoprefixer determines no actions are needed.\n    // ref: https://github.com/postcss/autoprefixer/blob/e2f5c26ff1f3eaca95a21873723ce1cdf6e59f0e/lib/info.js#L118\n    const autoprefixerInfo = autoprefixer.info();\n    const skipAutoprefixer = autoprefixerInfo.includes('Awesome!');\n\n    if (!skipAutoprefixer) {\n      this.autoprefixer = autoprefixer;\n    }\n  }\n\n  create(language: Readonly<StylesheetLanguage>): Plugin {\n    // Return a noop plugin if no load actions are required\n    if (!language.process && !this.autoprefixer && !this.options.tailwindConfiguration) {\n      return {\n        name: 'angular-' + language.name,\n        setup() {},\n      };\n    }\n\n    const { autoprefixer, cache, options } = this;\n\n    return {\n      name: 'angular-' + language.name,\n      async setup(build) {\n        // Setup postcss if needed by either autoprefixer or tailwind\n        // TODO: Move this into the plugin factory to avoid repeat setup per created plugin\n        let postcssProcessor: import('postcss').Processor | undefined;\n        if (autoprefixer || options.tailwindConfiguration) {\n          postcss ??= (await import('postcss')).default;\n          postcssProcessor = postcss();\n          if (options.tailwindConfiguration) {\n            const tailwind = await import(options.tailwindConfiguration.package);\n            postcssProcessor.use(tailwind.default({ config: options.tailwindConfiguration.file }));\n          }\n          if (autoprefixer) {\n            postcssProcessor.use(autoprefixer);\n          }\n        }\n\n        // Add a load callback to support inline Component styles\n        build.onLoad(\n          { filter: language.componentFilter, namespace: 'angular:styles/component' },\n          createCachedLoad(cache, async (args) => {\n            const data = options.inlineComponentData?.[args.path];\n            assert(\n              typeof data === 'string',\n              `component style name should always be found [${args.path}]`,\n            );\n\n            const [format, , filename] = args.path.split(';', 3);\n\n            return processStylesheet(\n              language,\n              data,\n              filename,\n              format,\n              options,\n              build,\n              postcssProcessor,\n            );\n          }),\n        );\n\n        // Add a load callback to support files from disk\n        build.onLoad(\n          { filter: language.fileFilter },\n          createCachedLoad(cache, async (args) => {\n            const data = await readFile(args.path, 'utf-8');\n\n            return processStylesheet(\n              language,\n              data,\n              args.path,\n              extname(args.path).toLowerCase().slice(1),\n              options,\n              build,\n              postcssProcessor,\n            );\n          }),\n        );\n      },\n    };\n  }\n}\n\nasync function processStylesheet(\n  language: Readonly<StylesheetLanguage>,\n  data: string,\n  filename: string,\n  format: string,\n  options: StylesheetPluginOptions,\n  build: PluginBuild,\n  postcssProcessor: import('postcss').Processor | undefined,\n) {\n  let result: OnLoadResult;\n\n  // Process the input data if the language requires preprocessing\n  if (language.process) {\n    result = await language.process(data, filename, format, options, build);\n  } else {\n    result = {\n      contents: data,\n      loader: 'css',\n      watchFiles: [filename],\n    };\n  }\n\n  // Transform with postcss if needed and there are no errors\n  if (postcssProcessor && result.contents && !result.errors?.length) {\n    const postcssResult = await compileString(\n      typeof result.contents === 'string'\n        ? result.contents\n        : Buffer.from(result.contents).toString('utf-8'),\n      filename,\n      postcssProcessor,\n      options,\n    );\n\n    // Merge results\n    if (postcssResult.errors?.length) {\n      delete result.contents;\n    }\n    if (result.warnings && postcssResult.warnings) {\n      postcssResult.warnings.unshift(...result.warnings);\n    }\n    if (result.watchFiles && postcssResult.watchFiles) {\n      postcssResult.watchFiles.unshift(...result.watchFiles);\n    }\n    if (result.watchDirs && postcssResult.watchDirs) {\n      postcssResult.watchDirs.unshift(...result.watchDirs);\n    }\n    result = {\n      ...result,\n      ...postcssResult,\n    };\n  }\n\n  return result;\n}\n\n/**\n * Compiles the provided CSS stylesheet data using a provided postcss processor and provides an\n * esbuild load result that can be used directly by an esbuild Plugin.\n * @param data The stylesheet content to process.\n * @param filename The name of the file that contains the data.\n * @param postcssProcessor A postcss processor instance to use.\n * @param options The plugin options to control the processing.\n * @returns An esbuild OnLoaderResult object with the processed content, warnings, and/or errors.\n */\nasync function compileString(\n  data: string,\n  filename: string,\n  postcssProcessor: import('postcss').Processor,\n  options: StylesheetPluginOptions,\n): Promise<OnLoadResult> {\n  try {\n    const result = await postcssProcessor.process(data, {\n      from: filename,\n      to: filename,\n      map: options.sourcemap && {\n        inline: true,\n        sourcesContent: true,\n      },\n    });\n\n    const rawWarnings = result.warnings();\n    let warnings;\n    if (rawWarnings.length > 0) {\n      const lineMappings = new Map<string, string[] | null>();\n      warnings = rawWarnings.map((warning) => {\n        const file = warning.node.source?.input.file;\n        if (file === undefined) {\n          return { text: warning.text };\n        }\n\n        let lines = lineMappings.get(file);\n        if (lines === undefined) {\n          lines = warning.node.source?.input.css.split(/\\r?\\n/);\n          lineMappings.set(file, lines ?? null);\n        }\n\n        return {\n          text: warning.text,\n          location: {\n            file,\n            line: warning.line,\n            column: warning.column - 1,\n            lineText: lines?.[warning.line - 1],\n          },\n        };\n      });\n    }\n\n    return {\n      contents: result.css,\n      loader: 'css',\n      warnings,\n    };\n  } catch (error) {\n    postcss ??= (await import('postcss')).default;\n    if (error instanceof postcss.CssSyntaxError) {\n      const lines = error.source?.split(/\\r?\\n/);\n\n      return {\n        errors: [\n          {\n            text: error.reason,\n            location: {\n              file: error.file,\n              line: error.line,\n              column: error.column && error.column - 1,\n              lineText: error.line === undefined ? undefined : lines?.[error.line - 1],\n            },\n          },\n        ],\n      };\n    }\n\n    throw error;\n  }\n}\n"]}

package/src/builders/browser-esbuild/virtual-module-plugin.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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 { OnLoadArgs, Plugin, PluginBuild } from 'esbuild';
+/**
+ * Options for the createVirtualModulePlugin
+ * @see createVirtualModulePlugin
+ */
+export interface VirtualModulePluginOptions {
+    /** Namespace. Example: `angular:polyfills`. */
+    namespace: string;
+    /** If the generated module should be marked as external. */
+    external?: boolean;
+    /** Method to transform the onResolve path. */
+    transformPath?: (path: string) => string;
+    /** Method to provide the module content. */
+    loadContent: (args: OnLoadArgs, build: PluginBuild) => ReturnType<Parameters<PluginBuild['onLoad']>[1]>;
+}
+/**
+ * Creates an esbuild plugin that generated virtual modules.
+ *
+ * @returns An esbuild plugin.
+ */
+export declare function createVirtualModulePlugin(options: VirtualModulePluginOptions): Plugin;

package/src/builders/browser-esbuild/virtual-module-plugin.js

@@ -0,0 +1,43 @@
+"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.createVirtualModulePlugin = void 0;
+/**
+ * Creates an esbuild plugin that generated virtual modules.
+ *
+ * @returns An esbuild plugin.
+ */
+function createVirtualModulePlugin(options) {
+    const { namespace, external, transformPath: pathTransformer, loadContent } = options;
+    return {
+        name: namespace.replace(/[/:]/g, '-'),
+        setup(build) {
+            build.onResolve({ filter: new RegExp('^' + namespace) }, ({ kind, path }) => {
+                if (kind !== 'entry-point') {
+                    return null;
+                }
+                return {
+                    path: pathTransformer?.(path) ?? path,
+                    namespace,
+                };
+            });
+            if (external) {
+                build.onResolve({ filter: /./, namespace }, ({ path }) => {
+                    return {
+                        path,
+                        external: true,
+                    };
+                });
+            }
+            build.onLoad({ filter: /./, namespace }, (args) => loadContent(args, build));
+        },
+    };
+}
+exports.createVirtualModulePlugin = createVirtualModulePlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/dev-server/load-proxy-config.js

@@ -31,7 +31,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeProxyConfiguration = exports.loadProxyConfiguration = void 0;
-const glob_1 = require("glob");
+const fast_glob_1 = require("fast-glob");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
@@ -96,7 +96,7 @@ exports.loadProxyConfiguration = loadProxyConfiguration;
 function normalizeProxyConfiguration(proxy) {
     // TODO: Consider upstreaming glob support
     for (const key of Object.keys(proxy)) {
-        if ((0, glob_1.hasMagic)(key)) {
+        if ((0, fast_glob_1.isDynamicPattern)(key)) {
             const { output } = (0, picomatch_1.parse)(key);
             proxy[`^${output}$`] = proxy[key];
             delete proxy[key];
@@ -127,4 +127,4 @@ function getJsonErrorLineColumn(offset, content) {
     }
     return { line, column: offset - position + 1 };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-proxy-config.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/dev-server/load-proxy-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { hasMagic as isDynamicPattern } from 'glob';\nimport { existsSync } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { extname, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { parse as parseGlob } from 'picomatch';\nimport { assertIsError } from '../../utils/error';\nimport { loadEsmModule } from '../../utils/load-esm';\n\nexport async function loadProxyConfiguration(root: string, proxyConfig: string | undefined) {\n  if (!proxyConfig) {\n    return undefined;\n  }\n\n  const proxyPath = resolve(root, proxyConfig);\n\n  if (!existsSync(proxyPath)) {\n    throw new Error(`Proxy configuration file ${proxyPath} does not exist.`);\n  }\n\n  switch (extname(proxyPath)) {\n    case '.json': {\n      const content = await readFile(proxyPath, 'utf-8');\n\n      const { parse, printParseErrorCode } = await import('jsonc-parser');\n      const parseErrors: import('jsonc-parser').ParseError[] = [];\n      const proxyConfiguration = parse(content, parseErrors, { allowTrailingComma: true });\n\n      if (parseErrors.length > 0) {\n        let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`;\n        for (const parseError of parseErrors) {\n          const { line, column } = getJsonErrorLineColumn(parseError.offset, content);\n          errorMessage += `\\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`;\n        }\n        throw new Error(errorMessage);\n      }\n\n      return proxyConfiguration;\n    }\n    case '.mjs':\n      // Load the ESM configuration file using the TypeScript dynamic import workaround.\n      // Once TypeScript provides support for keeping the dynamic import this workaround can be\n      // changed to a direct dynamic import.\n      return (await loadEsmModule<{ default: unknown }>(pathToFileURL(proxyPath))).default;\n    case '.cjs':\n      return require(proxyPath);\n    default:\n      // The file could be either CommonJS or ESM.\n      // CommonJS is tried first then ESM if loading fails.\n      try {\n        return require(proxyPath);\n      } catch (e) {\n        assertIsError(e);\n        if (e.code === 'ERR_REQUIRE_ESM') {\n          // Load the ESM configuration file using the TypeScript dynamic import workaround.\n          // Once TypeScript provides support for keeping the dynamic import this workaround can be\n          // changed to a direct dynamic import.\n          return (await loadEsmModule<{ default: unknown }>(pathToFileURL(proxyPath))).default;\n        }\n\n        throw e;\n      }\n  }\n}\n\n/**\n * Converts glob patterns to regular expressions to support Vite's proxy option.\n * @param proxy A proxy configuration object.\n */\nexport function normalizeProxyConfiguration(proxy: Record<string, unknown>) {\n  // TODO: Consider upstreaming glob support\n  for (const key of Object.keys(proxy)) {\n    if (isDynamicPattern(key)) {\n      const { output } = parseGlob(key);\n      proxy[`^${output}$`] = proxy[key];\n      delete proxy[key];\n    }\n  }\n}\n\n/**\n * Calculates the line and column for an error offset in the content of a JSON file.\n * @param location The offset error location from the beginning of the content.\n * @param content The full content of the file containing the error.\n * @returns An object containing the line and column\n */\nfunction getJsonErrorLineColumn(offset: number, content: string) {\n  if (offset === 0) {\n    return { line: 1, column: 1 };\n  }\n\n  let line = 0;\n  let position = 0;\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    ++line;\n\n    const nextNewline = content.indexOf('\\n', position);\n    if (nextNewline === -1 || nextNewline > offset) {\n      break;\n    }\n\n    position = nextNewline + 1;\n  }\n\n  return { line, column: offset - position + 1 };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-proxy-config.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/dev-server/load-proxy-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { isDynamicPattern } from 'fast-glob';\nimport { existsSync } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { extname, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { parse as parseGlob } from 'picomatch';\nimport { assertIsError } from '../../utils/error';\nimport { loadEsmModule } from '../../utils/load-esm';\n\nexport async function loadProxyConfiguration(root: string, proxyConfig: string | undefined) {\n  if (!proxyConfig) {\n    return undefined;\n  }\n\n  const proxyPath = resolve(root, proxyConfig);\n\n  if (!existsSync(proxyPath)) {\n    throw new Error(`Proxy configuration file ${proxyPath} does not exist.`);\n  }\n\n  switch (extname(proxyPath)) {\n    case '.json': {\n      const content = await readFile(proxyPath, 'utf-8');\n\n      const { parse, printParseErrorCode } = await import('jsonc-parser');\n      const parseErrors: import('jsonc-parser').ParseError[] = [];\n      const proxyConfiguration = parse(content, parseErrors, { allowTrailingComma: true });\n\n      if (parseErrors.length > 0) {\n        let errorMessage = `Proxy configuration file ${proxyPath} contains parse errors:`;\n        for (const parseError of parseErrors) {\n          const { line, column } = getJsonErrorLineColumn(parseError.offset, content);\n          errorMessage += `\\n[${line}, ${column}] ${printParseErrorCode(parseError.error)}`;\n        }\n        throw new Error(errorMessage);\n      }\n\n      return proxyConfiguration;\n    }\n    case '.mjs':\n      // Load the ESM configuration file using the TypeScript dynamic import workaround.\n      // Once TypeScript provides support for keeping the dynamic import this workaround can be\n      // changed to a direct dynamic import.\n      return (await loadEsmModule<{ default: unknown }>(pathToFileURL(proxyPath))).default;\n    case '.cjs':\n      return require(proxyPath);\n    default:\n      // The file could be either CommonJS or ESM.\n      // CommonJS is tried first then ESM if loading fails.\n      try {\n        return require(proxyPath);\n      } catch (e) {\n        assertIsError(e);\n        if (e.code === 'ERR_REQUIRE_ESM') {\n          // Load the ESM configuration file using the TypeScript dynamic import workaround.\n          // Once TypeScript provides support for keeping the dynamic import this workaround can be\n          // changed to a direct dynamic import.\n          return (await loadEsmModule<{ default: unknown }>(pathToFileURL(proxyPath))).default;\n        }\n\n        throw e;\n      }\n  }\n}\n\n/**\n * Converts glob patterns to regular expressions to support Vite's proxy option.\n * @param proxy A proxy configuration object.\n */\nexport function normalizeProxyConfiguration(proxy: Record<string, unknown>) {\n  // TODO: Consider upstreaming glob support\n  for (const key of Object.keys(proxy)) {\n    if (isDynamicPattern(key)) {\n      const { output } = parseGlob(key);\n      proxy[`^${output}$`] = proxy[key];\n      delete proxy[key];\n    }\n  }\n}\n\n/**\n * Calculates the line and column for an error offset in the content of a JSON file.\n * @param location The offset error location from the beginning of the content.\n * @param content The full content of the file containing the error.\n * @returns An object containing the line and column\n */\nfunction getJsonErrorLineColumn(offset: number, content: string) {\n  if (offset === 0) {\n    return { line: 1, column: 1 };\n  }\n\n  let line = 0;\n  let position = 0;\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    ++line;\n\n    const nextNewline = content.indexOf('\\n', position);\n    if (nextNewline === -1 || nextNewline > offset) {\n      break;\n    }\n\n    position = nextNewline + 1;\n  }\n\n  return { line, column: offset - position + 1 };\n}\n"]}