@angular-devkit/build-angular 16.1.0-next.2 → 16.1.0

package/src/tools/webpack/plugins/postcss-cli-resources.js

@@ -0,0 +1,176 @@
+"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.postcss = void 0;
+const loader_utils_1 = require("loader-utils");
+const path = __importStar(require("path"));
+const url = __importStar(require("url"));
+const error_1 = require("../../../utils/error");
+function wrapUrl(url) {
+    let wrappedUrl;
+    const hasSingleQuotes = url.indexOf("'") >= 0;
+    if (hasSingleQuotes) {
+        wrappedUrl = `"${url}"`;
+    }
+    else {
+        wrappedUrl = `'${url}'`;
+    }
+    return `url(${wrappedUrl})`;
+}
+async function resolve(file, base, resolver) {
+    try {
+        return await resolver('./' + file, base);
+    }
+    catch {
+        return resolver(file, base);
+    }
+}
+exports.postcss = true;
+function default_1(options) {
+    if (!options) {
+        throw new Error('No options were specified to "postcss-cli-resources".');
+    }
+    const { deployUrl = '', resourcesOutputPath = '', filename, loader, emitFile, extracted, } = options;
+    const process = async (inputUrl, context, resourceCache) => {
+        // If root-relative, absolute or protocol relative url, leave as is
+        if (/^((?:\w+:)?\/\/|data:|chrome:|#)/.test(inputUrl)) {
+            return inputUrl;
+        }
+        if (/^\//.test(inputUrl)) {
+            return inputUrl;
+        }
+        // If starts with a caret, remove and return remainder
+        // this supports bypassing asset processing
+        if (inputUrl.startsWith('^')) {
+            return inputUrl.slice(1);
+        }
+        const cacheKey = path.resolve(context, inputUrl);
+        const cachedUrl = resourceCache.get(cacheKey);
+        if (cachedUrl) {
+            return cachedUrl;
+        }
+        if (inputUrl.startsWith('~')) {
+            inputUrl = inputUrl.slice(1);
+        }
+        const { pathname, hash, search } = url.parse(inputUrl.replace(/\\/g, '/'));
+        const resolver = (file, base) => new Promise((resolve, reject) => {
+            loader.resolve(base, decodeURI(file), (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        const result = await resolve(pathname, context, resolver);
+        return new Promise((resolve, reject) => {
+            loader.fs.readFile(result, (err, content) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                let outputPath = (0, loader_utils_1.interpolateName)({ resourcePath: result }, filename(result), {
+                    content,
+                    context: loader.context || loader.rootContext,
+                }).replace(/\\|\//g, '-');
+                if (resourcesOutputPath) {
+                    outputPath = path.posix.join(resourcesOutputPath, outputPath);
+                }
+                loader.addDependency(result);
+                if (emitFile) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    loader.emitFile(outputPath, content, undefined, { sourceFilename: result });
+                }
+                let outputUrl = outputPath.replace(/\\/g, '/');
+                if (hash || search) {
+                    outputUrl = url.format({ pathname: outputUrl, hash, search });
+                }
+                if (deployUrl && !extracted) {
+                    outputUrl = url.resolve(deployUrl, outputUrl);
+                }
+                resourceCache.set(cacheKey, outputUrl);
+                resolve(outputUrl);
+            });
+        });
+    };
+    const resourceCache = new Map();
+    const processed = Symbol('postcss-cli-resources');
+    return {
+        postcssPlugin: 'postcss-cli-resources',
+        async Declaration(decl) {
+            if (!decl.value.includes('url') || processed in decl) {
+                return;
+            }
+            const value = decl.value;
+            const urlRegex = /url(?:\(\s*(['"]?))(.*?)(?:\1\s*\))/g;
+            const segments = [];
+            let match;
+            let lastIndex = 0;
+            let modified = false;
+            // We want to load it relative to the file that imports
+            const inputFile = decl.source && decl.source.input.file;
+            const context = (inputFile && path.dirname(inputFile)) || loader.context;
+            while ((match = urlRegex.exec(value))) {
+                const originalUrl = match[2];
+                let processedUrl;
+                try {
+                    processedUrl = await process(originalUrl, context, resourceCache);
+                }
+                catch (err) {
+                    (0, error_1.assertIsError)(err);
+                    loader.emitError(decl.error(err.message, { word: originalUrl }));
+                    continue;
+                }
+                if (lastIndex < match.index) {
+                    segments.push(value.slice(lastIndex, match.index));
+                }
+                if (!processedUrl || originalUrl === processedUrl) {
+                    segments.push(match[0]);
+                }
+                else {
+                    segments.push(wrapUrl(processedUrl));
+                    modified = true;
+                }
+                lastIndex = match.index + match[0].length;
+            }
+            if (lastIndex < value.length) {
+                segments.push(value.slice(lastIndex));
+            }
+            if (modified) {
+                decl.value = segments.join('');
+            }
+            decl[processed] = true;
+        },
+    };
+}
+exports.default = default_1;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"postcss-cli-resources.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/plugins/postcss-cli-resources.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 { interpolateName } from 'loader-utils';\nimport * as path from 'path';\nimport { Declaration, Plugin } from 'postcss';\nimport * as url from 'url';\nimport { assertIsError } from '../../../utils/error';\n\nfunction wrapUrl(url: string): string {\n  let wrappedUrl;\n  const hasSingleQuotes = url.indexOf(\"'\") >= 0;\n\n  if (hasSingleQuotes) {\n    wrappedUrl = `\"${url}\"`;\n  } else {\n    wrappedUrl = `'${url}'`;\n  }\n\n  return `url(${wrappedUrl})`;\n}\n\nexport interface PostcssCliResourcesOptions {\n  baseHref?: string;\n  deployUrl?: string;\n  resourcesOutputPath?: string;\n  rebaseRootRelative?: boolean;\n  /** CSS is extracted to a `.css` or is embedded in a `.js` file. */\n  extracted?: boolean;\n  filename: (resourcePath: string) => string;\n  loader: import('webpack').LoaderContext<unknown>;\n  emitFile: boolean;\n}\n\nasync function resolve(\n  file: string,\n  base: string,\n  resolver: (file: string, base: string) => Promise<string>,\n): Promise<string> {\n  try {\n    return await resolver('./' + file, base);\n  } catch {\n    return resolver(file, base);\n  }\n}\n\nexport const postcss = true;\n\nexport default function (options?: PostcssCliResourcesOptions): Plugin {\n  if (!options) {\n    throw new Error('No options were specified to \"postcss-cli-resources\".');\n  }\n\n  const {\n    deployUrl = '',\n    resourcesOutputPath = '',\n    filename,\n    loader,\n    emitFile,\n    extracted,\n  } = options;\n\n  const process = async (inputUrl: string, context: string, resourceCache: Map<string, string>) => {\n    // If root-relative, absolute or protocol relative url, leave as is\n    if (/^((?:\\w+:)?\\/\\/|data:|chrome:|#)/.test(inputUrl)) {\n      return inputUrl;\n    }\n\n    if (/^\\//.test(inputUrl)) {\n      return inputUrl;\n    }\n\n    // If starts with a caret, remove and return remainder\n    // this supports bypassing asset processing\n    if (inputUrl.startsWith('^')) {\n      return inputUrl.slice(1);\n    }\n\n    const cacheKey = path.resolve(context, inputUrl);\n    const cachedUrl = resourceCache.get(cacheKey);\n    if (cachedUrl) {\n      return cachedUrl;\n    }\n\n    if (inputUrl.startsWith('~')) {\n      inputUrl = inputUrl.slice(1);\n    }\n\n    const { pathname, hash, search } = url.parse(inputUrl.replace(/\\\\/g, '/'));\n    const resolver = (file: string, base: string) =>\n      new Promise<string>((resolve, reject) => {\n        loader.resolve(base, decodeURI(file), (err, result) => {\n          if (err) {\n            reject(err);\n\n            return;\n          }\n          resolve(result as string);\n        });\n      });\n\n    const result = await resolve(pathname as string, context, resolver);\n\n    return new Promise<string>((resolve, reject) => {\n      loader.fs.readFile(result, (err, content) => {\n        if (err) {\n          reject(err);\n\n          return;\n        }\n\n        let outputPath = interpolateName({ resourcePath: result }, filename(result), {\n          content,\n          context: loader.context || loader.rootContext,\n        }).replace(/\\\\|\\//g, '-');\n\n        if (resourcesOutputPath) {\n          outputPath = path.posix.join(resourcesOutputPath, outputPath);\n        }\n\n        loader.addDependency(result);\n        if (emitFile) {\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          loader.emitFile(outputPath, content!, undefined, { sourceFilename: result });\n        }\n\n        let outputUrl = outputPath.replace(/\\\\/g, '/');\n        if (hash || search) {\n          outputUrl = url.format({ pathname: outputUrl, hash, search });\n        }\n\n        if (deployUrl && !extracted) {\n          outputUrl = url.resolve(deployUrl, outputUrl);\n        }\n\n        resourceCache.set(cacheKey, outputUrl);\n        resolve(outputUrl);\n      });\n    });\n  };\n\n  const resourceCache = new Map<string, string>();\n  const processed = Symbol('postcss-cli-resources');\n\n  return {\n    postcssPlugin: 'postcss-cli-resources',\n    async Declaration(decl) {\n      if (!decl.value.includes('url') || processed in decl) {\n        return;\n      }\n\n      const value = decl.value;\n      const urlRegex = /url(?:\\(\\s*(['\"]?))(.*?)(?:\\1\\s*\\))/g;\n      const segments: string[] = [];\n\n      let match;\n      let lastIndex = 0;\n      let modified = false;\n\n      // We want to load it relative to the file that imports\n      const inputFile = decl.source && decl.source.input.file;\n      const context = (inputFile && path.dirname(inputFile)) || loader.context;\n\n      while ((match = urlRegex.exec(value))) {\n        const originalUrl = match[2];\n        let processedUrl;\n        try {\n          processedUrl = await process(originalUrl, context, resourceCache);\n        } catch (err) {\n          assertIsError(err);\n          loader.emitError(decl.error(err.message, { word: originalUrl }));\n          continue;\n        }\n\n        if (lastIndex < match.index) {\n          segments.push(value.slice(lastIndex, match.index));\n        }\n\n        if (!processedUrl || originalUrl === processedUrl) {\n          segments.push(match[0]);\n        } else {\n          segments.push(wrapUrl(processedUrl));\n          modified = true;\n        }\n\n        lastIndex = match.index + match[0].length;\n      }\n\n      if (lastIndex < value.length) {\n        segments.push(value.slice(lastIndex));\n      }\n\n      if (modified) {\n        decl.value = segments.join('');\n      }\n\n      (decl as Declaration & { [processed]: boolean })[processed] = true;\n    },\n  };\n}\n"]}

package/src/tools/webpack/plugins/progress-plugin.js

@@ -0,0 +1,39 @@
+"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.ProgressPlugin = void 0;
+const webpack_1 = require("webpack");
+const spinner_1 = require("../../../utils/spinner");
+class ProgressPlugin extends webpack_1.ProgressPlugin {
+    constructor(platform) {
+        const platformCapitalFirst = platform.replace(/^\w/, (s) => s.toUpperCase());
+        const spinner = new spinner_1.Spinner();
+        spinner.start(`Generating ${platform} application bundles (phase: setup)...`);
+        super({
+            handler: (percentage, message) => {
+                const phase = message ? ` (phase: ${message})` : '';
+                spinner.text = `Generating ${platform} application bundles${phase}...`;
+                switch (percentage) {
+                    case 1:
+                        if (spinner.isSpinning) {
+                            spinner.succeed(`${platformCapitalFirst} application bundle generation complete.`);
+                        }
+                        break;
+                    case 0:
+                        if (!spinner.isSpinning) {
+                            spinner.start();
+                        }
+                        break;
+                }
+            },
+        });
+    }
+}
+exports.ProgressPlugin = ProgressPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/webpack/plugins/remove-hash-plugin.js

@@ -0,0 +1,31 @@
+"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.RemoveHashPlugin = void 0;
+class RemoveHashPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('remove-hash-plugin', (compilation) => {
+            const assetPath = (path, data) => {
+                const chunkName = data.chunk?.name;
+                const { chunkNames, hashFormat } = this.options;
+                if (chunkName && chunkNames?.includes(chunkName)) {
+                    // Replace hash formats with empty strings.
+                    return path.replace(hashFormat.chunk, '').replace(hashFormat.extract, '');
+                }
+                return path;
+            };
+            compilation.hooks.assetPath.tap('remove-hash-plugin', assetPath);
+        });
+    }
+}
+exports.RemoveHashPlugin = RemoveHashPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/webpack/plugins/scripts-webpack-plugin.js

@@ -0,0 +1,180 @@
+"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.ScriptsWebpackPlugin = void 0;
+const loader_utils_1 = require("loader-utils");
+const path = __importStar(require("path"));
+const webpack_1 = require("webpack");
+const error_1 = require("../../../utils/error");
+const webpack_diagnostics_1 = require("../../../utils/webpack-diagnostics");
+const Entrypoint = require('webpack/lib/Entrypoint');
+/**
+ * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.
+ */
+const PLUGIN_NAME = 'scripts-webpack-plugin';
+function addDependencies(compilation, scripts) {
+    for (const script of scripts) {
+        compilation.fileDependencies.add(script);
+    }
+}
+class ScriptsWebpackPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    async shouldSkip(compilation, scripts) {
+        if (this._lastBuildTime == undefined) {
+            this._lastBuildTime = Date.now();
+            return false;
+        }
+        for (const script of scripts) {
+            const scriptTime = await new Promise((resolve, reject) => {
+                compilation.fileSystemInfo.getFileTimestamp(script, (error, entry) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve(entry && typeof entry !== 'string' ? entry.safeTime : undefined);
+                });
+            });
+            if (!scriptTime || scriptTime > this._lastBuildTime) {
+                this._lastBuildTime = Date.now();
+                return false;
+            }
+        }
+        return true;
+    }
+    _insertOutput(compilation, { filename, source }, cached = false) {
+        const chunk = new webpack_1.Chunk(this.options.name);
+        chunk.rendered = !cached;
+        chunk.id = this.options.name;
+        chunk.ids = [chunk.id];
+        chunk.files.add(filename);
+        const entrypoint = new Entrypoint(this.options.name);
+        entrypoint.pushChunk(chunk);
+        chunk.addGroup(entrypoint);
+        compilation.entrypoints.set(this.options.name, entrypoint);
+        compilation.chunks.add(chunk);
+        compilation.assets[filename] = source;
+        compilation.hooks.chunkAsset.call(chunk, filename);
+    }
+    apply(compiler) {
+        if (this.options.scripts.length === 0) {
+            return;
+        }
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            // Use the resolver from the compilation instead of compiler.
+            // Using the latter will causes a lot of `DescriptionFileUtils.loadDescriptionFile` calls.
+            // See: https://github.com/angular/angular-cli/issues/24634#issuecomment-1425782668
+            const resolver = compilation.resolverFactory.get('normal', {
+                preferRelative: true,
+                useSyncFileSystemCalls: true,
+                // Caching must be disabled because it causes the resolver to become async after a rebuild.
+                cache: false,
+            });
+            const scripts = [];
+            for (const script of this.options.scripts) {
+                try {
+                    const resolvedPath = resolver.resolveSync({}, this.options.basePath, script);
+                    if (resolvedPath) {
+                        scripts.push(resolvedPath);
+                    }
+                    else {
+                        (0, webpack_diagnostics_1.addError)(compilation, `Cannot resolve '${script}'.`);
+                    }
+                }
+                catch (error) {
+                    (0, error_1.assertIsError)(error);
+                    (0, webpack_diagnostics_1.addError)(compilation, error.message);
+                }
+            }
+            compilation.hooks.additionalAssets.tapPromise(PLUGIN_NAME, async () => {
+                if (await this.shouldSkip(compilation, scripts)) {
+                    if (this._cachedOutput) {
+                        this._insertOutput(compilation, this._cachedOutput, true);
+                    }
+                    addDependencies(compilation, scripts);
+                    return;
+                }
+                const sourceGetters = scripts.map((fullPath) => {
+                    return new Promise((resolve, reject) => {
+                        compilation.inputFileSystem.readFile(fullPath, (err, data) => {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            const content = data?.toString() ?? '';
+                            let source;
+                            if (this.options.sourceMap) {
+                                // TODO: Look for source map file (for '.min' scripts, etc.)
+                                let adjustedPath = fullPath;
+                                if (this.options.basePath) {
+                                    adjustedPath = path.relative(this.options.basePath, fullPath);
+                                }
+                                source = new webpack_1.sources.OriginalSource(content, adjustedPath);
+                            }
+                            else {
+                                source = new webpack_1.sources.RawSource(content);
+                            }
+                            resolve(source);
+                        });
+                    });
+                });
+                const sources = await Promise.all(sourceGetters);
+                const concatSource = new webpack_1.sources.ConcatSource();
+                sources.forEach((source) => {
+                    concatSource.add(source);
+                    concatSource.add('\n;');
+                });
+                const combinedSource = new webpack_1.sources.CachedSource(concatSource);
+                const output = { filename: this.options.filename, source: combinedSource };
+                this._insertOutput(compilation, output);
+                this._cachedOutput = output;
+                addDependencies(compilation, scripts);
+            });
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+            }, async () => {
+                const assetName = this.options.filename;
+                const asset = compilation.getAsset(assetName);
+                if (asset) {
+                    const interpolatedFilename = (0, loader_utils_1.interpolateName)({ resourcePath: 'scripts.js' }, assetName, { content: asset.source.source() });
+                    if (assetName !== interpolatedFilename) {
+                        compilation.renameAsset(assetName, interpolatedFilename);
+                    }
+                }
+            });
+        });
+    }
+}
+exports.ScriptsWebpackPlugin = ScriptsWebpackPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scripts-webpack-plugin.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/plugins/scripts-webpack-plugin.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 { interpolateName } from 'loader-utils';\nimport * as path from 'path';\nimport { Chunk, Compilation, Compiler, sources as webpackSources } from 'webpack';\nimport { assertIsError } from '../../../utils/error';\nimport { addError } from '../../../utils/webpack-diagnostics';\n\nconst Entrypoint = require('webpack/lib/Entrypoint');\n\n/**\n * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.\n */\nconst PLUGIN_NAME = 'scripts-webpack-plugin';\n\nexport interface ScriptsWebpackPluginOptions {\n  name: string;\n  sourceMap?: boolean;\n  scripts: string[];\n  filename: string;\n  basePath: string;\n}\n\ninterface ScriptOutput {\n  filename: string;\n  source: webpackSources.CachedSource;\n}\n\nfunction addDependencies(compilation: Compilation, scripts: string[]): void {\n  for (const script of scripts) {\n    compilation.fileDependencies.add(script);\n  }\n}\n\nexport class ScriptsWebpackPlugin {\n  private _lastBuildTime?: number;\n  private _cachedOutput?: ScriptOutput;\n\n  constructor(private options: ScriptsWebpackPluginOptions) {}\n\n  async shouldSkip(compilation: Compilation, scripts: string[]): Promise<boolean> {\n    if (this._lastBuildTime == undefined) {\n      this._lastBuildTime = Date.now();\n\n      return false;\n    }\n\n    for (const script of scripts) {\n      const scriptTime = await new Promise<number | undefined>((resolve, reject) => {\n        compilation.fileSystemInfo.getFileTimestamp(script, (error, entry) => {\n          if (error) {\n            reject(error);\n\n            return;\n          }\n\n          resolve(entry && typeof entry !== 'string' ? entry.safeTime : undefined);\n        });\n      });\n\n      if (!scriptTime || scriptTime > this._lastBuildTime) {\n        this._lastBuildTime = Date.now();\n\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private _insertOutput(\n    compilation: Compilation,\n    { filename, source }: ScriptOutput,\n    cached = false,\n  ) {\n    const chunk = new Chunk(this.options.name);\n    chunk.rendered = !cached;\n    chunk.id = this.options.name;\n    chunk.ids = [chunk.id];\n    chunk.files.add(filename);\n\n    const entrypoint = new Entrypoint(this.options.name);\n    entrypoint.pushChunk(chunk);\n    chunk.addGroup(entrypoint);\n    compilation.entrypoints.set(this.options.name, entrypoint);\n    compilation.chunks.add(chunk);\n\n    compilation.assets[filename] = source;\n    compilation.hooks.chunkAsset.call(chunk, filename);\n  }\n\n  apply(compiler: Compiler): void {\n    if (this.options.scripts.length === 0) {\n      return;\n    }\n\n    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {\n      // Use the resolver from the compilation instead of compiler.\n      // Using the latter will causes a lot of `DescriptionFileUtils.loadDescriptionFile` calls.\n      // See: https://github.com/angular/angular-cli/issues/24634#issuecomment-1425782668\n      const resolver = compilation.resolverFactory.get('normal', {\n        preferRelative: true,\n        useSyncFileSystemCalls: true,\n        // Caching must be disabled because it causes the resolver to become async after a rebuild.\n        cache: false,\n      });\n\n      const scripts: string[] = [];\n\n      for (const script of this.options.scripts) {\n        try {\n          const resolvedPath = resolver.resolveSync({}, this.options.basePath, script);\n          if (resolvedPath) {\n            scripts.push(resolvedPath);\n          } else {\n            addError(compilation, `Cannot resolve '${script}'.`);\n          }\n        } catch (error) {\n          assertIsError(error);\n          addError(compilation, error.message);\n        }\n      }\n\n      compilation.hooks.additionalAssets.tapPromise(PLUGIN_NAME, async () => {\n        if (await this.shouldSkip(compilation, scripts)) {\n          if (this._cachedOutput) {\n            this._insertOutput(compilation, this._cachedOutput, true);\n          }\n\n          addDependencies(compilation, scripts);\n\n          return;\n        }\n\n        const sourceGetters = scripts.map((fullPath) => {\n          return new Promise<webpackSources.Source>((resolve, reject) => {\n            compilation.inputFileSystem.readFile(\n              fullPath,\n              (err?: Error | null, data?: string | Buffer) => {\n                if (err) {\n                  reject(err);\n\n                  return;\n                }\n\n                const content = data?.toString() ?? '';\n\n                let source;\n                if (this.options.sourceMap) {\n                  // TODO: Look for source map file (for '.min' scripts, etc.)\n\n                  let adjustedPath = fullPath;\n                  if (this.options.basePath) {\n                    adjustedPath = path.relative(this.options.basePath, fullPath);\n                  }\n                  source = new webpackSources.OriginalSource(content, adjustedPath);\n                } else {\n                  source = new webpackSources.RawSource(content);\n                }\n\n                resolve(source);\n              },\n            );\n          });\n        });\n\n        const sources = await Promise.all(sourceGetters);\n        const concatSource = new webpackSources.ConcatSource();\n        sources.forEach((source) => {\n          concatSource.add(source);\n          concatSource.add('\\n;');\n        });\n\n        const combinedSource = new webpackSources.CachedSource(concatSource);\n\n        const output = { filename: this.options.filename, source: combinedSource };\n        this._insertOutput(compilation, output);\n        this._cachedOutput = output;\n        addDependencies(compilation, scripts);\n      });\n      compilation.hooks.processAssets.tapPromise(\n        {\n          name: PLUGIN_NAME,\n          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,\n        },\n        async () => {\n          const assetName = this.options.filename;\n          const asset = compilation.getAsset(assetName);\n          if (asset) {\n            const interpolatedFilename = interpolateName(\n              { resourcePath: 'scripts.js' },\n              assetName,\n              { content: asset.source.source() },\n            );\n            if (assetName !== interpolatedFilename) {\n              compilation.renameAsset(assetName, interpolatedFilename);\n            }\n          }\n        },\n      );\n    });\n  }\n}\n"]}

package/src/tools/webpack/plugins/service-worker-plugin.js

@@ -0,0 +1,46 @@
+"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.ServiceWorkerPlugin = void 0;
+const service_worker_1 = require("../../../utils/service-worker");
+class ServiceWorkerPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.done.tapPromise('angular-service-worker', async (stats) => {
+            if (stats.hasErrors()) {
+                // Don't generate a service worker if the compilation has errors.
+                // When there are errors some files will not be emitted which would cause other errors down the line such as readdir failures.
+                return;
+            }
+            const { projectRoot, root, baseHref = '', ngswConfigPath } = this.options;
+            const { compilation } = stats;
+            // We use the output path from the compilation instead of build options since during
+            // localization the output path is modified to a temp directory.
+            // See: https://github.com/angular/angular-cli/blob/7e64b1537d54fadb650559214fbb12707324cd75/packages/angular_devkit/build_angular/src/utils/i18n-options.ts#L251-L252
+            const outputPath = compilation.outputOptions.path;
+            if (!outputPath) {
+                throw new Error('Compilation output path cannot be empty.');
+            }
+            try {
+                await (0, service_worker_1.augmentAppWithServiceWorker)(projectRoot, root, outputPath, baseHref, ngswConfigPath, 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compiler.inputFileSystem.promises, 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compiler.outputFileSystem.promises);
+            }
+            catch (error) {
+                compilation.errors.push(new compilation.compiler.webpack.WebpackError(`Failed to generate service worker - ${error instanceof Error ? error.message : error}`));
+            }
+        });
+    }
+}
+exports.ServiceWorkerPlugin = ServiceWorkerPlugin;
+//# sourceMappingURL=data:application/json;base64,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

package/src/tools/webpack/plugins/styles-webpack-plugin.js

@@ -0,0 +1,73 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylesWebpackPlugin = void 0;
+const assert_1 = __importDefault(require("assert"));
+const error_1 = require("../../../utils/error");
+const webpack_diagnostics_1 = require("../../../utils/webpack-diagnostics");
+/**
+ * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.
+ */
+const PLUGIN_NAME = 'styles-webpack-plugin';
+class StylesWebpackPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { entryPoints, preserveSymlinks, root } = this.options;
+        const resolver = compiler.resolverFactory.get('global-styles', {
+            conditionNames: ['sass', 'less', 'style'],
+            mainFields: ['sass', 'less', 'style', 'main', '...'],
+            extensions: ['.scss', '.sass', '.less', '.css'],
+            restrictions: [/\.((le|sa|sc|c)ss)$/i],
+            preferRelative: true,
+            useSyncFileSystemCalls: true,
+            symlinks: !preserveSymlinks,
+            fileSystem: compiler.inputFileSystem,
+        });
+        const webpackOptions = compiler.options;
+        compiler.hooks.environment.tap(PLUGIN_NAME, () => {
+            const entry = typeof webpackOptions.entry === 'function' ? webpackOptions.entry() : webpackOptions.entry;
+            webpackOptions.entry = async () => {
+                var _a;
+                const entrypoints = await entry;
+                for (const [bundleName, paths] of Object.entries(entryPoints)) {
+                    entrypoints[bundleName] ?? (entrypoints[bundleName] = {});
+                    const entryImport = ((_a = entrypoints[bundleName]).import ?? (_a.import = []));
+                    for (const path of paths) {
+                        try {
+                            const resolvedPath = resolver.resolveSync({}, root, path);
+                            if (resolvedPath) {
+                                entryImport.push(`${resolvedPath}?ngGlobalStyle`);
+                            }
+                            else {
+                                (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.');
+                                (0, webpack_diagnostics_1.addError)(this.compilation, `Cannot resolve '${path}'.`);
+                            }
+                        }
+                        catch (error) {
+                            (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.');
+                            (0, error_1.assertIsError)(error);
+                            (0, webpack_diagnostics_1.addError)(this.compilation, error.message);
+                        }
+                    }
+                }
+                return entrypoints;
+            };
+        });
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            this.compilation = compilation;
+        });
+    }
+}
+exports.StylesWebpackPlugin = StylesWebpackPlugin;
+//# sourceMappingURL=data:application/json;base64,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