@angular-devkit/build-angular 16.0.0-next.4 → 16.0.0-next.6

package/src/utils/index-file/inline-critical-css.js

@@ -33,6 +33,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InlineCriticalCssProcessor = void 0;
 const fs = __importStar(require("fs"));
 const Critters = require('critters');
+/**
+ * Pattern used to extract the media query set by Critters in an `onload` handler.
+ */
+const MEDIA_SET_HANDLER_PATTERN = /^this\.media=["'](.*)["'];?$/;
+/**
+ * Name of the attribute used to save the Critters media query so it can be re-assigned on load.
+ */
+const CSP_MEDIA_ATTR = 'ngCspMedia';
+/**
+ * Script text used to change the media value of the link tags.
+ */
+const LINK_LOAD_SCRIPT_CONTENT = [
+    `(() => {`,
+    // Save the `children` in a variable since they're a live DOM node collection.
+    // We iterate over the direct descendants, instead of going through a `querySelectorAll`,
+    // because we know that the tags will be directly inside the `head`.
+    `  const children = document.head.children;`,
+    // Declare `onLoad` outside the loop to avoid leaking memory.
+    // Can't be an arrow function, because we need `this` to refer to the DOM node.
+    `  function onLoad() {this.media = this.getAttribute('${CSP_MEDIA_ATTR}');}`,
+    // Has to use a plain for loop, because some browsers don't support
+    // `forEach` on `children` which is a `HTMLCollection`.
+    `  for (let i = 0; i < children.length; i++) {`,
+    `    const child = children[i];`,
+    `    child.hasAttribute('${CSP_MEDIA_ATTR}') && child.addEventListener('load', onLoad);`,
+    `  }`,
+    `})();`,
+].join('\n');
 class CrittersExtended extends Critters {
     constructor(optionsExtended) {
         super({
@@ -48,6 +76,8 @@ class CrittersExtended extends Critters {
             pruneSource: false,
             reduceInlineStyles: false,
             mergeStylesheets: false,
+            // Note: if `preload` changes to anything other than `media`, the logic in
+            // `embedLinkedStylesheetOverride` will have to be updated.
             preload: 'media',
             noscriptFallback: true,
             inlineFonts: true,
@@ -55,11 +85,70 @@ class CrittersExtended extends Critters {
         this.optionsExtended = optionsExtended;
         this.warnings = [];
         this.errors = [];
+        this.addedCspScriptsDocuments = new WeakSet();
+        this.documentNonces = new WeakMap();
+        /**
+         * Override of the Critters `embedLinkedStylesheet` method
+         * that makes it work with Angular's CSP APIs.
+         */
+        this.embedLinkedStylesheetOverride = async (link, document) => {
+            const returnValue = await this.initialEmbedLinkedStylesheet(link, document);
+            const cspNonce = this.findCspNonce(document);
+            if (cspNonce) {
+                const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);
+                if (crittersMedia) {
+                    // If there's a Critters-generated `onload` handler and the file has an Angular CSP nonce,
+                    // we have to remove the handler, because it's incompatible with CSP. We save the value
+                    // in a different attribute and we generate a script tag with the nonce that uses
+                    // `addEventListener` to apply the media query instead.
+                    link.removeAttribute('onload');
+                    link.setAttribute(CSP_MEDIA_ATTR, crittersMedia[1]);
+                    this.conditionallyInsertCspLoadingScript(document, cspNonce);
+                }
+                link.prev?.setAttribute('nonce', cspNonce);
+            }
+            return returnValue;
+        };
+        // We can't use inheritance to override `embedLinkedStylesheet`, because it's not declared in
+        // the `Critters` .d.ts which means that we can't call the `super` implementation. TS doesn't
+        // allow for `super` to be cast to a different type.
+        this.initialEmbedLinkedStylesheet = this.embedLinkedStylesheet;
+        this.embedLinkedStylesheet = this.embedLinkedStylesheetOverride;
     }
     readFile(path) {
         const readAsset = this.optionsExtended.readAsset;
         return readAsset ? readAsset(path) : fs.promises.readFile(path, 'utf-8');
     }
+    /**
+     * Finds the CSP nonce for a specific document.
+     */
+    findCspNonce(document) {
+        if (this.documentNonces.has(document)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this.documentNonces.get(document);
+        }
+        // HTML attribute are case-insensitive, but the parser used by Critters is case-sensitive.
+        const nonceElement = document.querySelector('[ngCspNonce], [ngcspnonce]');
+        const cspNonce = nonceElement?.getAttribute('ngCspNonce') || nonceElement?.getAttribute('ngcspnonce') || null;
+        this.documentNonces.set(document, cspNonce);
+        return cspNonce;
+    }
+    /**
+     * Inserts the `script` tag that swaps the critical CSS at runtime,
+     * if one hasn't been inserted into the document already.
+     */
+    conditionallyInsertCspLoadingScript(document, nonce) {
+        if (this.addedCspScriptsDocuments.has(document)) {
+            return;
+        }
+        const script = document.createElement('script');
+        script.setAttribute('nonce', nonce);
+        script.textContent = LINK_LOAD_SCRIPT_CONTENT;
+        // Append the script to the head since it needs to
+        // run as early as possible, after the `link` tags.
+        document.head.appendChild(script);
+        this.addedCspScriptsDocuments.add(document);
+    }
 }
 class InlineCriticalCssProcessor {
     constructor(options) {
@@ -79,4 +168,4 @@ class InlineCriticalCssProcessor {
     }
 }
 exports.InlineCriticalCssProcessor = InlineCriticalCssProcessor;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inline-critical-css.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/utils/index-file/inline-critical-css.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 * as fs from 'fs';\n\nconst Critters: typeof import('critters').default = require('critters');\n\n/**\n * Pattern used to extract the media query set by Critters in an `onload` handler.\n */\nconst MEDIA_SET_HANDLER_PATTERN = /^this\\.media=[\"'](.*)[\"'];?$/;\n\n/**\n * Name of the attribute used to save the Critters media query so it can be re-assigned on load.\n */\nconst CSP_MEDIA_ATTR = 'ngCspMedia';\n\n/**\n * Script text used to change the media value of the link tags.\n */\nconst LINK_LOAD_SCRIPT_CONTENT = [\n  `(() => {`,\n  // Save the `children` in a variable since they're a live DOM node collection.\n  // We iterate over the direct descendants, instead of going through a `querySelectorAll`,\n  // because we know that the tags will be directly inside the `head`.\n  `  const children = document.head.children;`,\n  // Declare `onLoad` outside the loop to avoid leaking memory.\n  // Can't be an arrow function, because we need `this` to refer to the DOM node.\n  `  function onLoad() {this.media = this.getAttribute('${CSP_MEDIA_ATTR}');}`,\n  // Has to use a plain for loop, because some browsers don't support\n  // `forEach` on `children` which is a `HTMLCollection`.\n  `  for (let i = 0; i < children.length; i++) {`,\n  `    const child = children[i];`,\n  `    child.hasAttribute('${CSP_MEDIA_ATTR}') && child.addEventListener('load', onLoad);`,\n  `  }`,\n  `})();`,\n].join('\\n');\n\nexport interface InlineCriticalCssProcessOptions {\n  outputPath: string;\n}\n\nexport interface InlineCriticalCssProcessorOptions {\n  minify?: boolean;\n  deployUrl?: string;\n  readAsset?: (path: string) => Promise<string>;\n}\n\n/** Partial representation of an `HTMLElement`. */\ninterface PartialHTMLElement {\n  getAttribute(name: string): string | null;\n  setAttribute(name: string, value: string): void;\n  hasAttribute(name: string): boolean;\n  removeAttribute(name: string): void;\n  appendChild(child: PartialHTMLElement): void;\n  textContent: string;\n  tagName: string | null;\n  children: PartialHTMLElement[];\n  next: PartialHTMLElement | null;\n  prev: PartialHTMLElement | null;\n}\n\n/** Partial representation of an HTML `Document`. */\ninterface PartialDocument {\n  head: PartialHTMLElement;\n  createElement(tagName: string): PartialHTMLElement;\n  querySelector(selector: string): PartialHTMLElement | null;\n}\n\n/** Signature of the `Critters.embedLinkedStylesheet` method. */\ntype EmbedLinkedStylesheetFn = (\n  link: PartialHTMLElement,\n  document: PartialDocument,\n) => Promise<unknown>;\n\nclass CrittersExtended extends Critters {\n  readonly warnings: string[] = [];\n  readonly errors: string[] = [];\n  private initialEmbedLinkedStylesheet: EmbedLinkedStylesheetFn;\n  private addedCspScriptsDocuments = new WeakSet<PartialDocument>();\n  private documentNonces = new WeakMap<PartialDocument, string | null>();\n\n  // Inherited from `Critters`, but not exposed in the typings.\n  protected embedLinkedStylesheet!: EmbedLinkedStylesheetFn;\n\n  constructor(\n    private readonly optionsExtended: InlineCriticalCssProcessorOptions &\n      InlineCriticalCssProcessOptions,\n  ) {\n    super({\n      logger: {\n        warn: (s: string) => this.warnings.push(s),\n        error: (s: string) => this.errors.push(s),\n        info: () => {},\n      },\n      logLevel: 'warn',\n      path: optionsExtended.outputPath,\n      publicPath: optionsExtended.deployUrl,\n      compress: !!optionsExtended.minify,\n      pruneSource: false,\n      reduceInlineStyles: false,\n      mergeStylesheets: false,\n      // Note: if `preload` changes to anything other than `media`, the logic in\n      // `embedLinkedStylesheetOverride` will have to be updated.\n      preload: 'media',\n      noscriptFallback: true,\n      inlineFonts: true,\n    });\n\n    // We can't use inheritance to override `embedLinkedStylesheet`, because it's not declared in\n    // the `Critters` .d.ts which means that we can't call the `super` implementation. TS doesn't\n    // allow for `super` to be cast to a different type.\n    this.initialEmbedLinkedStylesheet = this.embedLinkedStylesheet;\n    this.embedLinkedStylesheet = this.embedLinkedStylesheetOverride;\n  }\n\n  public override readFile(path: string): Promise<string> {\n    const readAsset = this.optionsExtended.readAsset;\n\n    return readAsset ? readAsset(path) : fs.promises.readFile(path, 'utf-8');\n  }\n\n  /**\n   * Override of the Critters `embedLinkedStylesheet` method\n   * that makes it work with Angular's CSP APIs.\n   */\n  private embedLinkedStylesheetOverride: EmbedLinkedStylesheetFn = async (link, document) => {\n    const returnValue = await this.initialEmbedLinkedStylesheet(link, document);\n    const cspNonce = this.findCspNonce(document);\n\n    if (cspNonce) {\n      const crittersMedia = link.getAttribute('onload')?.match(MEDIA_SET_HANDLER_PATTERN);\n\n      if (crittersMedia) {\n        // If there's a Critters-generated `onload` handler and the file has an Angular CSP nonce,\n        // we have to remove the handler, because it's incompatible with CSP. We save the value\n        // in a different attribute and we generate a script tag with the nonce that uses\n        // `addEventListener` to apply the media query instead.\n        link.removeAttribute('onload');\n        link.setAttribute(CSP_MEDIA_ATTR, crittersMedia[1]);\n        this.conditionallyInsertCspLoadingScript(document, cspNonce);\n      }\n\n      link.prev?.setAttribute('nonce', cspNonce);\n    }\n\n    return returnValue;\n  };\n\n  /**\n   * Finds the CSP nonce for a specific document.\n   */\n  private findCspNonce(document: PartialDocument): string | null {\n    if (this.documentNonces.has(document)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.documentNonces.get(document)!;\n    }\n\n    // HTML attribute are case-insensitive, but the parser used by Critters is case-sensitive.\n    const nonceElement = document.querySelector('[ngCspNonce], [ngcspnonce]');\n    const cspNonce =\n      nonceElement?.getAttribute('ngCspNonce') || nonceElement?.getAttribute('ngcspnonce') || null;\n\n    this.documentNonces.set(document, cspNonce);\n\n    return cspNonce;\n  }\n\n  /**\n   * Inserts the `script` tag that swaps the critical CSS at runtime,\n   * if one hasn't been inserted into the document already.\n   */\n  private conditionallyInsertCspLoadingScript(document: PartialDocument, nonce: string): void {\n    if (this.addedCspScriptsDocuments.has(document)) {\n      return;\n    }\n\n    const script = document.createElement('script');\n    script.setAttribute('nonce', nonce);\n    script.textContent = LINK_LOAD_SCRIPT_CONTENT;\n    // Append the script to the head since it needs to\n    // run as early as possible, after the `link` tags.\n    document.head.appendChild(script);\n    this.addedCspScriptsDocuments.add(document);\n  }\n}\n\nexport class InlineCriticalCssProcessor {\n  constructor(protected readonly options: InlineCriticalCssProcessorOptions) {}\n\n  async process(\n    html: string,\n    options: InlineCriticalCssProcessOptions,\n  ): Promise<{ content: string; warnings: string[]; errors: string[] }> {\n    const critters = new CrittersExtended({ ...this.options, ...options });\n    const content = await critters.process(html);\n\n    return {\n      // Clean up value from value less attributes.\n      // This is caused because parse5 always requires attributes to have a string value.\n      // nomodule=\"\" defer=\"\" -> nomodule defer.\n      content: content.replace(/(\\s(?:defer|nomodule))=\"\"/g, '$1'),\n      errors: critters.errors,\n      warnings: critters.warnings,\n    };\n  }\n}\n"]}

package/src/utils/index-file/style-nonce.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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
+ */
+/**
+ * Finds the `ngCspNonce` value and copies it to all inline `<style>` tags.
+ * @param html Markup that should be processed.
+ */
+export declare function addStyleNonce(html: string): Promise<string>;

package/src/utils/index-file/style-nonce.js

@@ -0,0 +1,54 @@
+"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.addStyleNonce = void 0;
+const html_rewriting_stream_1 = require("./html-rewriting-stream");
+/**
+ * Pattern matching the name of the Angular nonce attribute. Note that this is
+ * case-insensitive, because HTML attribute names are case-insensitive as well.
+ */
+const NONCE_ATTR_PATTERN = /ngCspNonce/i;
+/**
+ * Finds the `ngCspNonce` value and copies it to all inline `<style>` tags.
+ * @param html Markup that should be processed.
+ */
+async function addStyleNonce(html) {
+    const nonce = await findNonce(html);
+    if (!nonce) {
+        return html;
+    }
+    const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(html);
+    rewriter.on('startTag', (tag) => {
+        if (tag.tagName === 'style' && !tag.attrs.some((attr) => attr.name === 'nonce')) {
+            tag.attrs.push({ name: 'nonce', value: nonce });
+        }
+        rewriter.emitStartTag(tag);
+    });
+    return transformedContent();
+}
+exports.addStyleNonce = addStyleNonce;
+/** Finds the Angular nonce in an HTML string. */
+async function findNonce(html) {
+    // Inexpensive check to avoid parsing the HTML when we're sure there's no nonce.
+    if (!NONCE_ATTR_PATTERN.test(html)) {
+        return null;
+    }
+    const { rewriter, transformedContent } = await (0, html_rewriting_stream_1.htmlRewritingStream)(html);
+    let nonce = null;
+    rewriter.on('startTag', (tag) => {
+        const nonceAttr = tag.attrs.find((attr) => NONCE_ATTR_PATTERN.test(attr.name));
+        if (nonceAttr?.value) {
+            nonce = nonceAttr.value;
+            rewriter.stop(); // Stop parsing since we've found the nonce.
+        }
+    });
+    await transformedContent();
+    return nonce;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/utils/service-worker.d.ts

@@ -5,8 +5,24 @@
  * 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 { Config } from '@angular/service-worker/config';
-import { promises as fsPromises } from 'fs';
+import type { Config, Filesystem } from '@angular/service-worker/config';
+import type { OutputFile } from 'esbuild';
+import { promises as fsPromises } from 'node:fs';
 export declare function augmentAppWithServiceWorker(appRoot: string, workspaceRoot: string, outputPath: string, baseHref: string, ngswConfigPath?: string, inputputFileSystem?: typeof fsPromises, outputFileSystem?: typeof fsPromises): Promise<void>;
-export declare function augmentAppWithServiceWorkerEsbuild(workspaceRoot: string, configPath: string, outputPath: string, baseHref: string): Promise<void>;
-export declare function augmentAppWithServiceWorkerCore(config: Config, outputPath: string, baseHref: string, inputputFileSystem?: typeof fsPromises, outputFileSystem?: typeof fsPromises): Promise<void>;
+export declare function augmentAppWithServiceWorkerEsbuild(workspaceRoot: string, configPath: string, baseHref: string, outputFiles: OutputFile[], assetFiles: {
+    source: string;
+    destination: string;
+}[]): Promise<{
+    manifest: string;
+    assetFiles: {
+        source: string;
+        destination: string;
+    }[];
+}>;
+export declare function augmentAppWithServiceWorkerCore(config: Config, serviceWorkerFilesystem: Filesystem, baseHref: string): Promise<{
+    manifest: string;
+    assetFiles: {
+        source: string;
+        destination: string;
+    }[];
+}>;

package/src/utils/service-worker.js

@@ -32,7 +32,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.augmentAppWithServiceWorkerCore = exports.augmentAppWithServiceWorkerEsbuild = exports.augmentAppWithServiceWorker = void 0;
 const crypto = __importStar(require("crypto"));
-const fs_1 = require("fs");
+const node_fs_1 = require("node:fs");
 const path = __importStar(require("path"));
 const error_1 = require("./error");
 const load_esm_1 = require("./load-esm");
@@ -78,7 +78,40 @@ class CliFilesystem {
         return items;
     }
 }
-async function augmentAppWithServiceWorker(appRoot, workspaceRoot, outputPath, baseHref, ngswConfigPath, inputputFileSystem = fs_1.promises, outputFileSystem = fs_1.promises) {
+class ResultFilesystem {
+    constructor(outputFiles, assetFiles) {
+        this.fileReaders = new Map();
+        for (const file of outputFiles) {
+            this.fileReaders.set('/' + file.path.replace(/\\/g, '/'), async () => file.text);
+        }
+        for (const file of assetFiles) {
+            this.fileReaders.set('/' + file.destination.replace(/\\/g, '/'), () => node_fs_1.promises.readFile(file.source, 'utf-8'));
+        }
+    }
+    async list(dir) {
+        if (dir !== '/') {
+            throw new Error('Serviceworker manifest generator should only list files from root.');
+        }
+        return [...this.fileReaders.keys()];
+    }
+    read(file) {
+        const reader = this.fileReaders.get(file);
+        if (reader === undefined) {
+            throw new Error('File does not exist.');
+        }
+        return reader();
+    }
+    async hash(file) {
+        return crypto
+            .createHash('sha1')
+            .update(await this.read(file))
+            .digest('hex');
+    }
+    write() {
+        throw new Error('Serviceworker manifest generator should not attempted to write.');
+    }
+}
+async function augmentAppWithServiceWorker(appRoot, workspaceRoot, outputPath, baseHref, ngswConfigPath, inputputFileSystem = node_fs_1.promises, outputFileSystem = node_fs_1.promises) {
     // Determine the configuration file path
     const configPath = ngswConfigPath
         ? path.join(workspaceRoot, ngswConfigPath)
@@ -100,15 +133,27 @@ async function augmentAppWithServiceWorker(appRoot, workspaceRoot, outputPath, b
             throw error;
         }
     }
-    return augmentAppWithServiceWorkerCore(config, outputPath, baseHref, inputputFileSystem, outputFileSystem);
+    const result = await augmentAppWithServiceWorkerCore(config, new CliFilesystem(outputFileSystem, outputPath), baseHref);
+    const copy = async (src, dest) => {
+        const resolvedDest = path.join(outputPath, dest);
+        return inputputFileSystem === outputFileSystem
+            ? // Native FS (Builder).
+                inputputFileSystem.copyFile(src, resolvedDest, node_fs_1.constants.COPYFILE_FICLONE)
+            : // memfs (Webpack): Read the file from the input FS (disk) and write it to the output FS (memory).
+                outputFileSystem.writeFile(resolvedDest, await inputputFileSystem.readFile(src));
+    };
+    await outputFileSystem.writeFile(path.join(outputPath, 'ngsw.json'), result.manifest);
+    for (const { source, destination } of result.assetFiles) {
+        await copy(source, destination);
+    }
 }
 exports.augmentAppWithServiceWorker = augmentAppWithServiceWorker;
 // This is currently used by the esbuild-based builder
-async function augmentAppWithServiceWorkerEsbuild(workspaceRoot, configPath, outputPath, baseHref) {
+async function augmentAppWithServiceWorkerEsbuild(workspaceRoot, configPath, baseHref, outputFiles, assetFiles) {
     // Read the configuration file
     let config;
     try {
-        const configurationData = await fs_1.promises.readFile(configPath, 'utf-8');
+        const configurationData = await node_fs_1.promises.readFile(configPath, 'utf-8');
         config = JSON.parse(configurationData);
     }
     catch (error) {
@@ -122,45 +167,33 @@ async function augmentAppWithServiceWorkerEsbuild(workspaceRoot, configPath, out
             throw error;
         }
     }
-    // TODO: Return the output files and any errors/warnings
-    return augmentAppWithServiceWorkerCore(config, outputPath, baseHref);
+    return augmentAppWithServiceWorkerCore(config, new ResultFilesystem(outputFiles, assetFiles), baseHref);
 }
 exports.augmentAppWithServiceWorkerEsbuild = augmentAppWithServiceWorkerEsbuild;
-async function augmentAppWithServiceWorkerCore(config, outputPath, baseHref, inputputFileSystem = fs_1.promises, outputFileSystem = fs_1.promises) {
+async function augmentAppWithServiceWorkerCore(config, serviceWorkerFilesystem, baseHref) {
     // Load ESM `@angular/service-worker/config` using the TypeScript dynamic import workaround.
     // Once TypeScript provides support for keeping the dynamic import this workaround can be
     // changed to a direct dynamic import.
     const GeneratorConstructor = (await (0, load_esm_1.loadEsmModule)('@angular/service-worker/config')).Generator;
     // Generate the manifest
-    const generator = new GeneratorConstructor(new CliFilesystem(outputFileSystem, outputPath), baseHref);
+    const generator = new GeneratorConstructor(serviceWorkerFilesystem, baseHref);
     const output = await generator.process(config);
     // Write the manifest
     const manifest = JSON.stringify(output, null, 2);
-    await outputFileSystem.writeFile(path.join(outputPath, 'ngsw.json'), manifest);
     // Find the service worker package
     const workerPath = require.resolve('@angular/service-worker/ngsw-worker.js');
-    const copy = async (src, dest) => {
-        const resolvedDest = path.join(outputPath, dest);
-        return inputputFileSystem === outputFileSystem
-            ? // Native FS (Builder).
-                inputputFileSystem.copyFile(src, resolvedDest, fs_1.constants.COPYFILE_FICLONE)
-            : // memfs (Webpack): Read the file from the input FS (disk) and write it to the output FS (memory).
-                outputFileSystem.writeFile(resolvedDest, await inputputFileSystem.readFile(src));
+    const result = {
+        manifest,
+        // Main worker code
+        assetFiles: [{ source: workerPath, destination: 'ngsw-worker.js' }],
     };
-    // Write the worker code
-    await copy(workerPath, 'ngsw-worker.js');
     // If present, write the safety worker code
-    try {
-        const safetyPath = path.join(path.dirname(workerPath), 'safety-worker.js');
-        await copy(safetyPath, 'worker-basic.min.js');
-        await copy(safetyPath, 'safety-worker.js');
-    }
-    catch (error) {
-        (0, error_1.assertIsError)(error);
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
+    const safetyPath = path.join(path.dirname(workerPath), 'safety-worker.js');
+    if ((0, node_fs_1.existsSync)(safetyPath)) {
+        result.assetFiles.push({ source: safetyPath, destination: 'worker-basic.min.js' });
+        result.assetFiles.push({ source: safetyPath, destination: 'safety-worker.js' });
     }
+    return result;
 }
 exports.augmentAppWithServiceWorkerCore = augmentAppWithServiceWorkerCore;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-worker.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/utils/service-worker.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 { Config, Filesystem } from '@angular/service-worker/config';\nimport * as crypto from 'crypto';\nimport { constants as fsConstants, promises as fsPromises } from 'fs';\nimport * as path from 'path';\nimport { assertIsError } from './error';\nimport { loadEsmModule } from './load-esm';\n\nclass CliFilesystem implements Filesystem {\n  constructor(private fs: typeof fsPromises, private base: string) {}\n\n  list(dir: string): Promise<string[]> {\n    return this._recursiveList(this._resolve(dir), []);\n  }\n\n  read(file: string): Promise<string> {\n    return this.fs.readFile(this._resolve(file), 'utf-8');\n  }\n\n  async hash(file: string): Promise<string> {\n    return crypto\n      .createHash('sha1')\n      .update(await this.fs.readFile(this._resolve(file)))\n      .digest('hex');\n  }\n\n  write(_file: string, _content: string): never {\n    throw new Error('This should never happen.');\n  }\n\n  private _resolve(file: string): string {\n    return path.join(this.base, file);\n  }\n\n  private async _recursiveList(dir: string, items: string[]): Promise<string[]> {\n    const subdirectories = [];\n    for (const entry of await this.fs.readdir(dir)) {\n      const entryPath = path.join(dir, entry);\n      const stats = await this.fs.stat(entryPath);\n\n      if (stats.isFile()) {\n        // Uses posix paths since the service worker expects URLs\n        items.push('/' + path.relative(this.base, entryPath).replace(/\\\\/g, '/'));\n      } else if (stats.isDirectory()) {\n        subdirectories.push(entryPath);\n      }\n    }\n\n    for (const subdirectory of subdirectories) {\n      await this._recursiveList(subdirectory, items);\n    }\n\n    return items;\n  }\n}\n\nexport async function augmentAppWithServiceWorker(\n  appRoot: string,\n  workspaceRoot: string,\n  outputPath: string,\n  baseHref: string,\n  ngswConfigPath?: string,\n  inputputFileSystem = fsPromises,\n  outputFileSystem = fsPromises,\n): Promise<void> {\n  // Determine the configuration file path\n  const configPath = ngswConfigPath\n    ? path.join(workspaceRoot, ngswConfigPath)\n    : path.join(appRoot, 'ngsw-config.json');\n\n  // Read the configuration file\n  let config: Config | undefined;\n  try {\n    const configurationData = await inputputFileSystem.readFile(configPath, 'utf-8');\n    config = JSON.parse(configurationData) as Config;\n  } catch (error) {\n    assertIsError(error);\n    if (error.code === 'ENOENT') {\n      throw new Error(\n        'Error: Expected to find an ngsw-config.json configuration file' +\n          ` in the ${appRoot} folder. Either provide one or` +\n          ' disable Service Worker in the angular.json configuration file.',\n      );\n    } else {\n      throw error;\n    }\n  }\n\n  return augmentAppWithServiceWorkerCore(\n    config,\n    outputPath,\n    baseHref,\n    inputputFileSystem,\n    outputFileSystem,\n  );\n}\n\n// This is currently used by the esbuild-based builder\nexport async function augmentAppWithServiceWorkerEsbuild(\n  workspaceRoot: string,\n  configPath: string,\n  outputPath: string,\n  baseHref: string,\n): Promise<void> {\n  // Read the configuration file\n  let config: Config | undefined;\n  try {\n    const configurationData = await fsPromises.readFile(configPath, 'utf-8');\n    config = JSON.parse(configurationData) as Config;\n  } catch (error) {\n    assertIsError(error);\n    if (error.code === 'ENOENT') {\n      // TODO: Generate an error object that can be consumed by the esbuild-based builder\n      const message = `Service worker configuration file \"${path.relative(\n        workspaceRoot,\n        configPath,\n      )}\" could not be found.`;\n      throw new Error(message);\n    } else {\n      throw error;\n    }\n  }\n\n  // TODO: Return the output files and any errors/warnings\n  return augmentAppWithServiceWorkerCore(config, outputPath, baseHref);\n}\n\nexport async function augmentAppWithServiceWorkerCore(\n  config: Config,\n  outputPath: string,\n  baseHref: string,\n  inputputFileSystem = fsPromises,\n  outputFileSystem = fsPromises,\n): Promise<void> {\n  // Load ESM `@angular/service-worker/config` 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  const GeneratorConstructor = (\n    await loadEsmModule<typeof import('@angular/service-worker/config')>(\n      '@angular/service-worker/config',\n    )\n  ).Generator;\n\n  // Generate the manifest\n  const generator = new GeneratorConstructor(\n    new CliFilesystem(outputFileSystem, outputPath),\n    baseHref,\n  );\n  const output = await generator.process(config);\n\n  // Write the manifest\n  const manifest = JSON.stringify(output, null, 2);\n  await outputFileSystem.writeFile(path.join(outputPath, 'ngsw.json'), manifest);\n\n  // Find the service worker package\n  const workerPath = require.resolve('@angular/service-worker/ngsw-worker.js');\n\n  const copy = async (src: string, dest: string): Promise<void> => {\n    const resolvedDest = path.join(outputPath, dest);\n\n    return inputputFileSystem === outputFileSystem\n      ? // Native FS (Builder).\n        inputputFileSystem.copyFile(src, resolvedDest, fsConstants.COPYFILE_FICLONE)\n      : // memfs (Webpack): Read the file from the input FS (disk) and write it to the output FS (memory).\n        outputFileSystem.writeFile(resolvedDest, await inputputFileSystem.readFile(src));\n  };\n\n  // Write the worker code\n  await copy(workerPath, 'ngsw-worker.js');\n\n  // If present, write the safety worker code\n  try {\n    const safetyPath = path.join(path.dirname(workerPath), 'safety-worker.js');\n    await copy(safetyPath, 'worker-basic.min.js');\n    await copy(safetyPath, 'safety-worker.js');\n  } catch (error) {\n    assertIsError(error);\n    if (error.code !== 'ENOENT') {\n      throw error;\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-worker.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/build_angular/src/utils/service-worker.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 { Config, Filesystem } from '@angular/service-worker/config';\nimport * as crypto from 'crypto';\nimport type { OutputFile } from 'esbuild';\nimport { existsSync, constants as fsConstants, promises as fsPromises } from 'node:fs';\nimport * as path from 'path';\nimport { assertIsError } from './error';\nimport { loadEsmModule } from './load-esm';\n\nclass CliFilesystem implements Filesystem {\n  constructor(private fs: typeof fsPromises, private base: string) {}\n\n  list(dir: string): Promise<string[]> {\n    return this._recursiveList(this._resolve(dir), []);\n  }\n\n  read(file: string): Promise<string> {\n    return this.fs.readFile(this._resolve(file), 'utf-8');\n  }\n\n  async hash(file: string): Promise<string> {\n    return crypto\n      .createHash('sha1')\n      .update(await this.fs.readFile(this._resolve(file)))\n      .digest('hex');\n  }\n\n  write(_file: string, _content: string): never {\n    throw new Error('This should never happen.');\n  }\n\n  private _resolve(file: string): string {\n    return path.join(this.base, file);\n  }\n\n  private async _recursiveList(dir: string, items: string[]): Promise<string[]> {\n    const subdirectories = [];\n    for (const entry of await this.fs.readdir(dir)) {\n      const entryPath = path.join(dir, entry);\n      const stats = await this.fs.stat(entryPath);\n\n      if (stats.isFile()) {\n        // Uses posix paths since the service worker expects URLs\n        items.push('/' + path.relative(this.base, entryPath).replace(/\\\\/g, '/'));\n      } else if (stats.isDirectory()) {\n        subdirectories.push(entryPath);\n      }\n    }\n\n    for (const subdirectory of subdirectories) {\n      await this._recursiveList(subdirectory, items);\n    }\n\n    return items;\n  }\n}\n\nclass ResultFilesystem implements Filesystem {\n  private readonly fileReaders = new Map<string, () => Promise<string>>();\n\n  constructor(outputFiles: OutputFile[], assetFiles: { source: string; destination: string }[]) {\n    for (const file of outputFiles) {\n      this.fileReaders.set('/' + file.path.replace(/\\\\/g, '/'), async () => file.text);\n    }\n    for (const file of assetFiles) {\n      this.fileReaders.set('/' + file.destination.replace(/\\\\/g, '/'), () =>\n        fsPromises.readFile(file.source, 'utf-8'),\n      );\n    }\n  }\n\n  async list(dir: string): Promise<string[]> {\n    if (dir !== '/') {\n      throw new Error('Serviceworker manifest generator should only list files from root.');\n    }\n\n    return [...this.fileReaders.keys()];\n  }\n\n  read(file: string): Promise<string> {\n    const reader = this.fileReaders.get(file);\n    if (reader === undefined) {\n      throw new Error('File does not exist.');\n    }\n\n    return reader();\n  }\n\n  async hash(file: string): Promise<string> {\n    return crypto\n      .createHash('sha1')\n      .update(await this.read(file))\n      .digest('hex');\n  }\n\n  write(): never {\n    throw new Error('Serviceworker manifest generator should not attempted to write.');\n  }\n}\n\nexport async function augmentAppWithServiceWorker(\n  appRoot: string,\n  workspaceRoot: string,\n  outputPath: string,\n  baseHref: string,\n  ngswConfigPath?: string,\n  inputputFileSystem = fsPromises,\n  outputFileSystem = fsPromises,\n): Promise<void> {\n  // Determine the configuration file path\n  const configPath = ngswConfigPath\n    ? path.join(workspaceRoot, ngswConfigPath)\n    : path.join(appRoot, 'ngsw-config.json');\n\n  // Read the configuration file\n  let config: Config | undefined;\n  try {\n    const configurationData = await inputputFileSystem.readFile(configPath, 'utf-8');\n    config = JSON.parse(configurationData) as Config;\n  } catch (error) {\n    assertIsError(error);\n    if (error.code === 'ENOENT') {\n      throw new Error(\n        'Error: Expected to find an ngsw-config.json configuration file' +\n          ` in the ${appRoot} folder. Either provide one or` +\n          ' disable Service Worker in the angular.json configuration file.',\n      );\n    } else {\n      throw error;\n    }\n  }\n\n  const result = await augmentAppWithServiceWorkerCore(\n    config,\n    new CliFilesystem(outputFileSystem, outputPath),\n    baseHref,\n  );\n\n  const copy = async (src: string, dest: string): Promise<void> => {\n    const resolvedDest = path.join(outputPath, dest);\n\n    return inputputFileSystem === outputFileSystem\n      ? // Native FS (Builder).\n        inputputFileSystem.copyFile(src, resolvedDest, fsConstants.COPYFILE_FICLONE)\n      : // memfs (Webpack): Read the file from the input FS (disk) and write it to the output FS (memory).\n        outputFileSystem.writeFile(resolvedDest, await inputputFileSystem.readFile(src));\n  };\n\n  await outputFileSystem.writeFile(path.join(outputPath, 'ngsw.json'), result.manifest);\n\n  for (const { source, destination } of result.assetFiles) {\n    await copy(source, destination);\n  }\n}\n\n// This is currently used by the esbuild-based builder\nexport async function augmentAppWithServiceWorkerEsbuild(\n  workspaceRoot: string,\n  configPath: string,\n  baseHref: string,\n  outputFiles: OutputFile[],\n  assetFiles: { source: string; destination: string }[],\n): Promise<{ manifest: string; assetFiles: { source: string; destination: string }[] }> {\n  // Read the configuration file\n  let config: Config | undefined;\n  try {\n    const configurationData = await fsPromises.readFile(configPath, 'utf-8');\n    config = JSON.parse(configurationData) as Config;\n  } catch (error) {\n    assertIsError(error);\n    if (error.code === 'ENOENT') {\n      // TODO: Generate an error object that can be consumed by the esbuild-based builder\n      const message = `Service worker configuration file \"${path.relative(\n        workspaceRoot,\n        configPath,\n      )}\" could not be found.`;\n      throw new Error(message);\n    } else {\n      throw error;\n    }\n  }\n\n  return augmentAppWithServiceWorkerCore(\n    config,\n    new ResultFilesystem(outputFiles, assetFiles),\n    baseHref,\n  );\n}\n\nexport async function augmentAppWithServiceWorkerCore(\n  config: Config,\n  serviceWorkerFilesystem: Filesystem,\n  baseHref: string,\n): Promise<{ manifest: string; assetFiles: { source: string; destination: string }[] }> {\n  // Load ESM `@angular/service-worker/config` 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  const GeneratorConstructor = (\n    await loadEsmModule<typeof import('@angular/service-worker/config')>(\n      '@angular/service-worker/config',\n    )\n  ).Generator;\n\n  // Generate the manifest\n  const generator = new GeneratorConstructor(serviceWorkerFilesystem, baseHref);\n  const output = await generator.process(config);\n\n  // Write the manifest\n  const manifest = JSON.stringify(output, null, 2);\n\n  // Find the service worker package\n  const workerPath = require.resolve('@angular/service-worker/ngsw-worker.js');\n\n  const result = {\n    manifest,\n    // Main worker code\n    assetFiles: [{ source: workerPath, destination: 'ngsw-worker.js' }],\n  };\n\n  // If present, write the safety worker code\n  const safetyPath = path.join(path.dirname(workerPath), 'safety-worker.js');\n  if (existsSync(safetyPath)) {\n    result.assetFiles.push({ source: safetyPath, destination: 'worker-basic.min.js' });\n    result.assetFiles.push({ source: safetyPath, destination: 'safety-worker.js' });\n  }\n\n  return result;\n}\n"]}