html-webpack-plugin 5.5.4 → 5.6.1

package/lib/cached-child-compiler.js

@@ -3,7 +3,7 @@
  * @file
  * Helper plugin manages the cached state of the child compilation
  *
- * To optimize performance the child compilation is running asyncronously.
+ * To optimize performance the child compilation is running asynchronously.
  * Therefore it needs to be started in the compiler.make phase and ends after
  * the compilation.afterCompile phase.
  *
@@ -21,7 +21,7 @@
     });
  * ```
  */
-'use strict';
+"use strict";
 
 // Import types
 /** @typedef {import("webpack").Compiler} Compiler */
@@ -37,7 +37,7 @@
   error: Error
 }} ChildCompilationResult */
 
-const { HtmlWebpackChildCompiler } = require('./child-compiler');
+const { HtmlWebpackChildCompiler } = require("./child-compiler");
 
 /**
  * This plugin is a singleton for performance reasons.
@@ -51,7 +51,7 @@ class CachedChildCompilation {
   /**
    * @param {Compiler} compiler
    */
-  constructor (compiler) {
+  constructor(compiler) {
     /**
      * @private
      * @type {Compiler}
@@ -62,7 +62,8 @@ class CachedChildCompilation {
     if (compilerMap.has(compiler)) {
       return;
     }
-    const persistentChildCompilerSingletonPlugin = new PersistentChildCompilerSingletonPlugin();
+    const persistentChildCompilerSingletonPlugin =
+      new PersistentChildCompilerSingletonPlugin();
     compilerMap.set(compiler, persistentChildCompilerSingletonPlugin);
     persistentChildCompilerSingletonPlugin.apply(compiler);
   }
@@ -71,21 +72,25 @@ class CachedChildCompilation {
    * apply is called by the webpack main compiler during the start phase
    * @param {string} entry
    */
-  addEntry (entry) {
-    const persistentChildCompilerSingletonPlugin = compilerMap.get(this.compiler);
+  addEntry(entry) {
+    const persistentChildCompilerSingletonPlugin = compilerMap.get(
+      this.compiler,
+    );
     if (!persistentChildCompilerSingletonPlugin) {
       throw new Error(
-        'PersistentChildCompilerSingletonPlugin instance not found.'
+        "PersistentChildCompilerSingletonPlugin instance not found.",
       );
     }
     persistentChildCompilerSingletonPlugin.addEntry(entry);
   }
 
-  getCompilationResult () {
-    const persistentChildCompilerSingletonPlugin = compilerMap.get(this.compiler);
+  getCompilationResult() {
+    const persistentChildCompilerSingletonPlugin = compilerMap.get(
+      this.compiler,
+    );
     if (!persistentChildCompilerSingletonPlugin) {
       throw new Error(
-        'PersistentChildCompilerSingletonPlugin instance not found.'
+        "PersistentChildCompilerSingletonPlugin instance not found.",
       );
     }
     return persistentChildCompilerSingletonPlugin.getLatestResult();
@@ -99,16 +104,18 @@ class CachedChildCompilation {
       | { mainCompilationHash: string, compiledEntry: ChildCompilationTemplateResult }
     }
    */
-  getCompilationEntryResult (entry) {
+  getCompilationEntryResult(entry) {
     const latestResult = this.getCompilationResult();
     const compilationResult = latestResult.compilationResult;
-    return 'error' in compilationResult ? {
-      mainCompilationHash: latestResult.mainCompilationHash,
-      error: compilationResult.error
-    } : {
-      mainCompilationHash: latestResult.mainCompilationHash,
-      compiledEntry: compilationResult.compiledEntries[entry]
-    };
+    return "error" in compilationResult
+      ? {
+          mainCompilationHash: latestResult.mainCompilationHash,
+          error: compilationResult.error,
+        }
+      : {
+          mainCompilationHash: latestResult.mainCompilationHash,
+          compiledEntry: compilationResult.compiledEntries[entry],
+        };
   }
 }
 
@@ -119,7 +126,7 @@ class PersistentChildCompilerSingletonPlugin {
    * @param {Compilation} mainCompilation
    * @param {number} startTime
    */
-  static createSnapshot (fileDependencies, mainCompilation, startTime) {
+  static createSnapshot(fileDependencies, mainCompilation, startTime) {
     return new Promise((resolve, reject) => {
       mainCompilation.fileSystemInfo.createSnapshot(
         startTime,
@@ -133,7 +140,7 @@ class PersistentChildCompilerSingletonPlugin {
             return reject(err);
           }
           resolve(snapshot);
-        }
+        },
       );
     });
   }
@@ -146,7 +153,7 @@ class PersistentChildCompilerSingletonPlugin {
    * @param {Compilation} mainCompilation
    * @returns {Promise<boolean | undefined>}
    */
-  static isSnapshotValid (snapshot, mainCompilation) {
+  static isSnapshotValid(snapshot, mainCompilation) {
     return new Promise((resolve, reject) => {
       mainCompilation.fileSystemInfo.checkSnapshotValid(
         snapshot,
@@ -155,20 +162,20 @@ class PersistentChildCompilerSingletonPlugin {
             reject(err);
           }
           resolve(isValid);
-        }
+        },
       );
     });
   }
 
-  static watchFiles (mainCompilation, fileDependencies) {
-    Object.keys(fileDependencies).forEach((depencyTypes) => {
-      fileDependencies[depencyTypes].forEach(fileDependency => {
-        mainCompilation[depencyTypes].add(fileDependency);
+  static watchFiles(mainCompilation, fileDependencies) {
+    Object.keys(fileDependencies).forEach((dependencyType) => {
+      fileDependencies[dependencyType].forEach((fileDependency) => {
+        mainCompilation[dependencyType].add(fileDependency);
       });
     });
   }
 
-  constructor () {
+  constructor() {
     /**
      * @private
      * @type {
@@ -198,15 +205,15 @@ class PersistentChildCompilerSingletonPlugin {
       isVerifyingCache: false,
       entries: [],
       compiledEntries: [],
-      mainCompilationHash: 'initial',
+      mainCompilationHash: "initial",
       compilationResult: {
         dependencies: {
           fileDependencies: [],
           contextDependencies: [],
-          missingDependencies: []
+          missingDependencies: [],
         },
-        compiledEntries: {}
-      }
+        compiledEntries: {},
+      },
     };
   }
 
@@ -214,31 +221,34 @@ class PersistentChildCompilerSingletonPlugin {
    * apply is called by the webpack main compiler during the start phase
    * @param {Compiler} compiler
    */
-  apply (compiler) {
+  apply(compiler) {
     /** @type Promise<ChildCompilationResult> */
     let childCompilationResultPromise = Promise.resolve({
       dependencies: {
         fileDependencies: [],
         contextDependencies: [],
-        missingDependencies: []
+        missingDependencies: [],
       },
-      compiledEntries: {}
+      compiledEntries: {},
     });
     /**
      * The main compilation hash which will only be updated
      * if the childCompiler changes
      */
     /** @type {string} */
-    let mainCompilationHashOfLastChildRecompile = '';
+    let mainCompilationHashOfLastChildRecompile = "";
     /** @type {Snapshot | undefined} */
     let previousFileSystemSnapshot;
     let compilationStartTime = new Date().getTime();
 
     compiler.hooks.make.tapAsync(
-      'PersistentChildCompilerSingletonPlugin',
+      "PersistentChildCompilerSingletonPlugin",
       (mainCompilation, callback) => {
-        if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
-          return callback(new Error('Child compilation has already started'));
+        if (
+          this.compilationState.isCompiling ||
+          this.compilationState.isVerifyingCache
+        ) {
+          return callback(new Error("Child compilation has already started"));
         }
 
         // Update the time to the current compile start time
@@ -250,83 +260,101 @@ class PersistentChildCompilerSingletonPlugin {
           isVerifyingCache: true,
           previousEntries: this.compilationState.compiledEntries,
           previousResult: this.compilationState.compilationResult,
-          entries: this.compilationState.entries
+          entries: this.compilationState.entries,
         };
 
         // Validate cache:
-        const isCacheValidPromise = this.isCacheValid(previousFileSystemSnapshot, mainCompilation);
+        const isCacheValidPromise = this.isCacheValid(
+          previousFileSystemSnapshot,
+          mainCompilation,
+        );
 
         let cachedResult = childCompilationResultPromise;
-        childCompilationResultPromise = isCacheValidPromise.then((isCacheValid) => {
-          // Reuse cache
-          if (isCacheValid) {
-            return cachedResult;
-          }
-          // Start the compilation
-          const compiledEntriesPromise = this.compileEntries(
-            mainCompilation,
-            this.compilationState.entries
-          );
-          // Update snapshot as soon as we know the filedependencies
-          // this might possibly cause bugs if files were changed inbetween
-          // compilation start and snapshot creation
-          compiledEntriesPromise.then((childCompilationResult) => {
-            return PersistentChildCompilerSingletonPlugin.createSnapshot(childCompilationResult.dependencies, mainCompilation, compilationStartTime);
-          }).then((snapshot) => {
-            previousFileSystemSnapshot = snapshot;
-          });
-          return compiledEntriesPromise;
-        });
+        childCompilationResultPromise = isCacheValidPromise.then(
+          (isCacheValid) => {
+            // Reuse cache
+            if (isCacheValid) {
+              return cachedResult;
+            }
+            // Start the compilation
+            const compiledEntriesPromise = this.compileEntries(
+              mainCompilation,
+              this.compilationState.entries,
+            );
+            // Update snapshot as soon as we know the fileDependencies
+            // this might possibly cause bugs if files were changed between
+            // compilation start and snapshot creation
+            compiledEntriesPromise
+              .then((childCompilationResult) => {
+                return PersistentChildCompilerSingletonPlugin.createSnapshot(
+                  childCompilationResult.dependencies,
+                  mainCompilation,
+                  compilationStartTime,
+                );
+              })
+              .then((snapshot) => {
+                previousFileSystemSnapshot = snapshot;
+              });
+            return compiledEntriesPromise;
+          },
+        );
 
         // Add files to compilation which needs to be watched:
         mainCompilation.hooks.optimizeTree.tapAsync(
-          'PersistentChildCompilerSingletonPlugin',
+          "PersistentChildCompilerSingletonPlugin",
           (chunks, modules, callback) => {
-            const handleCompilationDonePromise = childCompilationResultPromise.then(
-              childCompilationResult => {
+            const handleCompilationDonePromise =
+              childCompilationResultPromise.then((childCompilationResult) => {
                 this.watchFiles(
                   mainCompilation,
-                  childCompilationResult.dependencies
+                  childCompilationResult.dependencies,
                 );
               });
-            // @ts-ignore
-            handleCompilationDonePromise.then(() => callback(null, chunks, modules), callback);
-          }
+            handleCompilationDonePromise.then(
+              // @ts-ignore
+              () => callback(null, chunks, modules),
+              callback,
+            );
+          },
         );
 
         // Store the final compilation once the main compilation hash is known
         mainCompilation.hooks.additionalAssets.tapAsync(
-          'PersistentChildCompilerSingletonPlugin',
+          "PersistentChildCompilerSingletonPlugin",
           (callback) => {
-            const didRecompilePromise = Promise.all([childCompilationResultPromise, cachedResult]).then(
-              ([childCompilationResult, cachedResult]) => {
-                // Update if childCompilation changed
-                return (cachedResult !== childCompilationResult);
-              }
-            );
+            const didRecompilePromise = Promise.all([
+              childCompilationResultPromise,
+              cachedResult,
+            ]).then(([childCompilationResult, cachedResult]) => {
+              // Update if childCompilation changed
+              return cachedResult !== childCompilationResult;
+            });
 
-            const handleCompilationDonePromise = Promise.all([childCompilationResultPromise, didRecompilePromise]).then(
-              ([childCompilationResult, didRecompile]) => {
-                // Update hash and snapshot if childCompilation changed
-                if (didRecompile) {
-                  mainCompilationHashOfLastChildRecompile = /** @type {string} */ (mainCompilation.hash);
-                }
-                this.compilationState = {
-                  isCompiling: false,
-                  isVerifyingCache: false,
-                  entries: this.compilationState.entries,
-                  compiledEntries: this.compilationState.entries,
-                  compilationResult: childCompilationResult,
-                  mainCompilationHash: mainCompilationHashOfLastChildRecompile
-                };
-              });
+            const handleCompilationDonePromise = Promise.all([
+              childCompilationResultPromise,
+              didRecompilePromise,
+            ]).then(([childCompilationResult, didRecompile]) => {
+              // Update hash and snapshot if childCompilation changed
+              if (didRecompile) {
+                mainCompilationHashOfLastChildRecompile =
+                  /** @type {string} */ (mainCompilation.hash);
+              }
+              this.compilationState = {
+                isCompiling: false,
+                isVerifyingCache: false,
+                entries: this.compilationState.entries,
+                compiledEntries: this.compilationState.entries,
+                compilationResult: childCompilationResult,
+                mainCompilationHash: mainCompilationHashOfLastChildRecompile,
+              };
+            });
             handleCompilationDonePromise.then(() => callback(null), callback);
-          }
+          },
         );
 
         // Continue compilation:
         callback(null);
-      }
+      },
     );
   }
 
@@ -334,12 +362,15 @@ class PersistentChildCompilerSingletonPlugin {
    * Add a new entry to the next compile run
    * @param {string} entry
    */
-  addEntry (entry) {
-    if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
+  addEntry(entry) {
+    if (
+      this.compilationState.isCompiling ||
+      this.compilationState.isVerifyingCache
+    ) {
       throw new Error(
-        'The child compiler has already started to compile. ' +
-        "Please add entries before the main compiler 'make' phase has started or " +
-        'after the compilation is done.'
+        "The child compiler has already started to compile. " +
+          "Please add entries before the main compiler 'make' phase has started or " +
+          "after the compilation is done.",
       );
     }
     if (this.compilationState.entries.indexOf(entry) === -1) {
@@ -347,17 +378,20 @@ class PersistentChildCompilerSingletonPlugin {
     }
   }
 
-  getLatestResult () {
-    if (this.compilationState.isCompiling || this.compilationState.isVerifyingCache) {
+  getLatestResult() {
+    if (
+      this.compilationState.isCompiling ||
+      this.compilationState.isVerifyingCache
+    ) {
       throw new Error(
-        'The child compiler is not done compiling. ' +
-        "Please access the result after the compiler 'make' phase has started or " +
-        'after the compilation is done.'
+        "The child compiler is not done compiling. " +
+          "Please access the result after the compiler 'make' phase has started or " +
+          "after the compilation is done.",
       );
     }
     return {
       mainCompilationHash: this.compilationState.mainCompilationHash,
-      compilationResult: this.compilationState.compilationResult
+      compilationResult: this.compilationState.compilationResult,
     };
   }
 
@@ -368,16 +402,22 @@ class PersistentChildCompilerSingletonPlugin {
    * @param {Compilation} mainCompilation
    * @returns {Promise<boolean | undefined>}
    */
-  isCacheValid (snapshot, mainCompilation) {
+  isCacheValid(snapshot, mainCompilation) {
     if (!this.compilationState.isVerifyingCache) {
-      return Promise.reject(new Error('Cache validation can only be done right before the compilation starts'));
+      return Promise.reject(
+        new Error(
+          "Cache validation can only be done right before the compilation starts",
+        ),
+      );
     }
     // If there are no entries we don't need a new child compilation
     if (this.compilationState.entries.length === 0) {
       return Promise.resolve(true);
     }
     // If there are new entries the cache is invalid
-    if (this.compilationState.entries !== this.compilationState.previousEntries) {
+    if (
+      this.compilationState.entries !== this.compilationState.previousEntries
+    ) {
       return Promise.resolve(false);
     }
     // Mark the cache as invalid if there is no snapshot
@@ -385,7 +425,10 @@ class PersistentChildCompilerSingletonPlugin {
       return Promise.resolve(false);
     }
 
-    return PersistentChildCompilerSingletonPlugin.isSnapshotValid(snapshot, mainCompilation);
+    return PersistentChildCompilerSingletonPlugin.isSnapshotValid(
+      snapshot,
+      mainCompilation,
+    );
   }
 
   /**
@@ -396,29 +439,32 @@ class PersistentChildCompilerSingletonPlugin {
    * @param {string[]} entries
    * @returns {Promise<ChildCompilationResult>}
    */
-  compileEntries (mainCompilation, entries) {
+  compileEntries(mainCompilation, entries) {
     const compiler = new HtmlWebpackChildCompiler(entries);
-    return compiler.compileTemplates(mainCompilation).then((result) => {
-      return {
-      // The compiled sources to render the content
-        compiledEntries: result,
+    return compiler.compileTemplates(mainCompilation).then(
+      (result) => {
+        return {
+          // The compiled sources to render the content
+          compiledEntries: result,
+          // The file dependencies to find out if a
+          // recompilation is required
+          dependencies: compiler.fileDependencies,
+          // The main compilation hash can be used to find out
+          // if this compilation was done during the current compilation
+          mainCompilationHash: mainCompilation.hash,
+        };
+      },
+      (error) => ({
+        // The compiled sources to render the content
+        error,
         // The file dependencies to find out if a
         // recompilation is required
         dependencies: compiler.fileDependencies,
         // The main compilation hash can be used to find out
         // if this compilation was done during the current compilation
-        mainCompilationHash: mainCompilation.hash
-      };
-    }, error => ({
-      // The compiled sources to render the content
-      error,
-      // The file dependencies to find out if a
-      // recompilation is required
-      dependencies: compiler.fileDependencies,
-      // The main compilation hash can be used to find out
-      // if this compilation was done during the current compilation
-      mainCompilationHash: mainCompilation.hash
-    }));
+        mainCompilationHash: mainCompilation.hash,
+      }),
+    );
   }
 
   /**
@@ -426,11 +472,11 @@ class PersistentChildCompilerSingletonPlugin {
    * @param {Compilation} mainCompilation
    * @param {FileDependencies} files
    */
-  watchFiles (mainCompilation, files) {
+  watchFiles(mainCompilation, files) {
     PersistentChildCompilerSingletonPlugin.watchFiles(mainCompilation, files);
   }
 }
 
 module.exports = {
-  CachedChildCompilation
+  CachedChildCompilation,
 };