style(JavascriptModulesPlugin): add space and use destructuring

Author: michael-ciniawsky

lib/JavascriptModulesPlugin.js

@@ -42,13 +42,17 @@ class JavascriptModulesPlugin {
 				"The 'compilation' argument must be an instance of Compilation"
 			);
 		}
+
 		let hooks = compilationHooksMap.get(compilation);
+
 		if (hooks === undefined) {
 			hooks = {
 				shouldRender: new SyncBailHook(["module", "chunk"])
 			};
+
 			compilationHooksMap.set(compilation, hooks);
 		}
+
 		return hooks;
 	}
 
@@ -57,67 +61,82 @@ class JavascriptModulesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
+		const { compilation } = compiler.hooks;
+
+		compilation.tap(
 			"JavascriptModulesPlugin",
 			(compilation, { normalModuleFactory }) => {
-				const moduleGraph = compilation.moduleGraph;
 				const hooks = JavascriptModulesPlugin.getHooks(compilation);
+
 				hooks.shouldRender.tap("JavascriptModulesPlugin", module => {
 					if (module.type === "javascript/auto") return true;
 					if (module.type === "javascript/dynamic") return true;
 					if (module.type === "javascript/esm") return true;
 				});
-				normalModuleFactory.hooks.createParser
+
+				const { createParser, createGenerator } = normalModuleFactory.hooks;
+
+				createParser
 					.for("javascript/auto")
 					.tap("JavascriptModulesPlugin", options => {
 						return new JavascriptParser(options, "auto");
 					});
-				normalModuleFactory.hooks.createParser
+				createParser
 					.for("javascript/dynamic")
 					.tap("JavascriptModulesPlugin", options => {
 						return new JavascriptParser(options, "script");
 					});
-				normalModuleFactory.hooks.createParser
+				createParser
 					.for("javascript/esm")
 					.tap("JavascriptModulesPlugin", options => {
 						return new JavascriptParser(options, "module");
 					});
-				normalModuleFactory.hooks.createGenerator
+
+				createGenerator
 					.for("javascript/auto")
 					.tap("JavascriptModulesPlugin", () => {
 						return new JavascriptGenerator();
 					});
-				normalModuleFactory.hooks.createGenerator
+				createGenerator
 					.for("javascript/dynamic")
 					.tap("JavascriptModulesPlugin", () => {
 						return new JavascriptGenerator();
 					});
-				normalModuleFactory.hooks.createGenerator
+				createGenerator
 					.for("javascript/esm")
 					.tap("JavascriptModulesPlugin", () => {
 						return new JavascriptGenerator();
 					});
-				compilation.mainTemplate.hooks.renderManifest.tap(
+
+				const { moduleGraph } = compilation;
+				const { contentHash } = compilation.hooks;
+				const { mainTemplate, chunkTemplate } = compilation;
+
+				mainTemplate.hooks.renderManifest.tap(
 					"JavascriptModulesPlugin",
 					(result, options) => {
 						const chunk = options.chunk;
-						const hash = options.hash;
-						const outputOptions = options.outputOptions;
+						const { filename } = options.outputOptions;
+						const { hash } = options;
+						const { moduleGraph, chunkGraph } = options;
+
+						const mainTemplate = compilation.mainTemplate;
+
+						const filenameTemplate = chunk.filenameTemplate || filename;
+
+						const runtimeTemplate = options.runtimeTemplate;
 						const moduleTemplates = options.moduleTemplates;
 						const dependencyTemplates = options.dependencyTemplates;
 
-						const filenameTemplate =
-							chunk.filenameTemplate || outputOptions.filename;
-
 						result.push({
 							render: () =>
-								compilation.mainTemplate.render(moduleTemplates.javascript, {
+								mainTemplate.render(moduleTemplates.javascript, {
 									hash,
 									chunk,
-									dependencyTemplates,
-									runtimeTemplate: options.runtimeTemplate,
-									moduleGraph: options.moduleGraph,
-									chunkGraph: options.chunkGraph
+									chunkGraph,
+									moduleGraph,
+									runtimeTemplate,
+									dependencyTemplates
 								}),
 							filenameTemplate,
 							pathOptions: {
@@ -130,7 +149,8 @@ class JavascriptModulesPlugin {
 						return result;
 					}
 				);
-				compilation.mainTemplate.hooks.modules.tap(
+
+				mainTemplate.hooks.modules.tap(
 					"JavascriptModulesPlugin",
 					(source, moduleTemplate, renderContext) => {
 						const chunk = renderContext.chunk;
@@ -142,23 +162,26 @@ class JavascriptModulesPlugin {
 						);
 					}
 				);
-				compilation.chunkTemplate.hooks.renderManifest.tap(
+
+				chunkTemplate.hooks.renderManifest.tap(
 					"JavascriptModulesPlugin",
 					(result, options) => {
 						const chunk = options.chunk;
-						const outputOptions = options.outputOptions;
-						const moduleTemplates = options.moduleTemplates;
-						const dependencyTemplates = options.dependencyTemplates;
+						const { filename, chunkFilename } = options.outputOptions;
 
 						let filenameTemplate;
+
 						if (chunk.filenameTemplate) {
 							filenameTemplate = chunk.filenameTemplate;
 						} else if (chunk.isOnlyInitial()) {
-							filenameTemplate = outputOptions.filename;
+							filenameTemplate = filename;
 						} else {
-							filenameTemplate = outputOptions.chunkFilename;
+							filenameTemplate = chunkFilename;
 						}
 
+						const { chunkTemplate, runtimeTemplate } = compilation;
+						const { moduleTemplates, dependencyTemplates } = options;
+
 						const { chunkGraph } = compilation;
 
 						const hasModules = Array.from(
@@ -176,14 +199,14 @@ class JavascriptModulesPlugin {
 								render: () =>
 									this.renderJavascript(
 										compilation,
-										compilation.chunkTemplate,
+										chunkTemplate,
 										moduleTemplates.javascript,
 										{
 											chunk,
-											dependencyTemplates,
-											runtimeTemplate: compilation.runtimeTemplate,
+											chunkGraph,
 											moduleGraph,
-											chunkGraph: compilation.chunkGraph
+											runtimeTemplate,
+											dependencyTemplates
 										}
 									),
 								filenameTemplate,
@@ -199,10 +222,13 @@ class JavascriptModulesPlugin {
 						}
 					}
 				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+
+				contentHash.tap("JavascriptModulesPlugin", chunk => {
 					const {
 						chunkGraph,
 						moduleGraph,
+						mainTemplate,
+						chunkTemplate,
 						runtimeTemplate,
 						outputOptions: {
 							hashSalt,
@@ -211,18 +237,22 @@ class JavascriptModulesPlugin {
 							hashFunction
 						}
 					} = compilation;
+
 					const hash = createHash(hashFunction);
+
 					if (hashSalt) hash.update(hashSalt);
-					const template = chunk.hasRuntime()
-						? compilation.mainTemplate
-						: compilation.chunkTemplate;
+
+					const template = chunk.hasRuntime() ? mainTemplate : chunkTemplate;
+
 					hash.update(`${chunk.id} `);
 					hash.update(chunk.ids ? chunk.ids.join(",") : "");
+
 					template.updateHashForChunk(hash, chunk, {
 						chunkGraph,
 						moduleGraph,
 						runtimeTemplate
 					});
+
 					for (const m of chunkGraph.getOrderedChunkModulesIterable(
 						chunk,
 						compareModulesById(chunkGraph)
@@ -231,6 +261,7 @@ class JavascriptModulesPlugin {
 							hash.update(chunkGraph.getModuleHash(m));
 						}
 					}
+
 					chunk.contentHash.javascript = hash
 						.digest(hashDigest)
 						.substr(0, hashDigestLength);
@@ -250,25 +281,31 @@ class JavascriptModulesPlugin {
 		const hooks = JavascriptModulesPlugin.getHooks(compilation);
 
 		const chunk = renderContext.chunk;
+
 		const moduleSources = Template.renderChunkModules(
 			renderContext,
-			m => hooks.shouldRender.call(m, chunk),
+			module => hooks.shouldRender.call(module, chunk),
 			moduleTemplate
 		);
+
 		const core = chunkTemplate.hooks.modules.call(
 			moduleSources,
 			moduleTemplate,
 			renderContext
 		);
+
 		let source = chunkTemplate.hooks.render.call(
 			core,
 			moduleTemplate,
 			renderContext
 		);
+
 		if (renderContext.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 			source = chunkTemplate.hooks.renderWithEntry.call(source, chunk);
 		}
+
 		chunk.rendered = true;
+
 		return new ConcatSource(source, ";");
 	}
 }