webpack 4.10.1 → 4.10.2

package/lib/Module.js

@@ -225,8 +225,9 @@ class Module extends DependenciesBlock {
 
 	hasReasonForChunk(chunk) {
 		if (this._rewriteChunkInReasons) {
-			for (const operation of this._rewriteChunkInReasons)
+			for (const operation of this._rewriteChunkInReasons) {
 				this._doRewriteChunkInReasons(operation.oldChunk, operation.newChunks);
+			}
 			this._rewriteChunkInReasons = undefined;
 		}
 		for (let i = 0; i < this.reasons.length; i++) {
@@ -241,8 +242,9 @@ class Module extends DependenciesBlock {
 
 	rewriteChunkInReasons(oldChunk, newChunks) {
 		// This is expensive. Delay operation until we really need the data
-		if (this._rewriteChunkInReasons === undefined)
+		if (this._rewriteChunkInReasons === undefined) {
 			this._rewriteChunkInReasons = [];
+		}
 		this._rewriteChunkInReasons.push({
 			oldChunk,
 			newChunks
@@ -266,13 +268,15 @@ class Module extends DependenciesBlock {
 
 		// Mangle export name if possible
 		if (this.isProvided(exportName)) {
-			if (this.buildMeta.exportsType === "namespace")
+			if (this.buildMeta.exportsType === "namespace") {
 				return Template.numberToIdentifer(idx);
-			else if (
+			}
+			if (
 				this.buildMeta.exportsType === "named" &&
 				!this.usedExports.includes("default")
-			)
+			) {
 				return Template.numberToIdentifer(idx);
+			}
 		}
 		return exportName;
 	}

package/lib/ModuleFilenameHelpers.js

@@ -48,8 +48,9 @@ const getHash = str => {
 };
 
 const asRegExp = test => {
-	if (typeof test === "string")
+	if (typeof test === "string") {
 		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+	}
 	return test;
 };
 
@@ -141,7 +142,9 @@ ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 		if (countMap[item].length > 1) {
 			if (comparator && countMap[item][0] === i) return item;
 			return fn(item, i, posMap[item]++);
-		} else return item;
+		} else {
+			return item;
+		}
 	});
 };
 
@@ -156,11 +159,20 @@ ModuleFilenameHelpers.matchPart = (str, test) => {
 };
 
 ModuleFilenameHelpers.matchObject = (obj, str) => {
-	if (obj.test)
-		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) return false;
-	if (obj.include)
-		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) return false;
-	if (obj.exclude)
-		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) return false;
+	if (obj.test) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
+			return false;
+		}
+	}
+	if (obj.include) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
+			return false;
+		}
+	}
+	if (obj.exclude) {
+		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
+			return false;
+		}
+	}
 	return true;
 };

package/lib/MultiCompiler.js

@@ -162,8 +162,11 @@ module.exports = class MultiCompiler extends Tapable {
 			for (const c of list) {
 				const ready =
 					!c.dependencies || c.dependencies.every(isDependencyFulfilled);
-				if (ready) readyCompilers.push(c);
-				else remainingCompilers.push(c);
+				if (ready) {
+					readyCompilers.push(c);
+				} else {
+					remainingCompilers.push(c);
+				}
 			}
 			return readyCompilers;
 		};
@@ -233,12 +236,16 @@ module.exports = class MultiCompiler extends Tapable {
 	}
 
 	run(callback) {
-		if (this.running) return callback(new ConcurrentCompilationError());
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
+		}
 
 		const finalCallback = (err, stats) => {
 			this.running = false;
 
-			if (callback !== undefined) return callback(err, stats);
+			if (callback !== undefined) {
+				return callback(err, stats);
+			}
 		};
 
 		const allStats = this.compilers.map(() => null);
@@ -249,13 +256,17 @@ module.exports = class MultiCompiler extends Tapable {
 				(compiler, callback) => {
 					const compilerIdx = this.compilers.indexOf(compiler);
 					compiler.run((err, stats) => {
-						if (err) return callback(err);
+						if (err) {
+							return callback(err);
+						}
 						allStats[compilerIdx] = stats;
 						callback();
 					});
 				},
 				err => {
-					if (err) return finalCallback(err);
+					if (err) {
+						return finalCallback(err);
+					}
 					finalCallback(null, new MultiStats(allStats));
 				}
 			);
@@ -264,8 +275,9 @@ module.exports = class MultiCompiler extends Tapable {
 
 	purgeInputFileSystem() {
 		for (const compiler of this.compilers) {
-			if (compiler.inputFileSystem && compiler.inputFileSystem.purge)
+			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
 				compiler.inputFileSystem.purge();
+			}
 		}
 	}
 };

package/lib/MultiModule.js

@@ -56,10 +56,13 @@ class MultiModule extends Module {
 		let idx = 0;
 		for (const dep of this.dependencies) {
 			if (dep.module) {
-				if (idx === this.dependencies.length - 1) str.push("module.exports = ");
+				if (idx === this.dependencies.length - 1) {
+					str.push("module.exports = ");
+				}
 				str.push("__webpack_require__(");
-				if (runtimeTemplate.outputOptions.pathinfo)
+				if (runtimeTemplate.outputOptions.pathinfo) {
 					str.push(Template.toComment(dep.request));
+				}
 				str.push(`${JSON.stringify(dep.module.id)}`);
 				str.push(")");
 			} else {

package/lib/NodeStuffPlugin.js

@@ -30,8 +30,9 @@ class NodeStuffPlugin {
 					if (parserOptions.node === false) return;
 
 					let localOptions = options;
-					if (parserOptions.node)
+					if (parserOptions.node) {
 						localOptions = Object.assign({}, localOptions, parserOptions.node);
+					}
 
 					const setConstant = (expressionName, value) => {
 						parser.hooks.expression

package/lib/NormalModule.js

@@ -153,12 +153,15 @@ class NormalModule extends Module {
 		const loaderContext = {
 			version: 2,
 			emitWarning: warning => {
-				if (!(warning instanceof Error))
+				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
+				}
 				this.warnings.push(new ModuleWarning(this, warning));
 			},
 			emitError: error => {
-				if (!(error instanceof Error)) error = new NonErrorEmittedError(error);
+				if (!(error instanceof Error)) {
+					error = new NonErrorEmittedError(error);
+				}
 				this.errors.push(new ModuleError(this, error));
 			},
 			exec: (code, filename) => {
@@ -174,7 +177,9 @@ class NormalModule extends Module {
 				resolver.resolve({}, context, request, {}, callback);
 			},
 			emitFile: (name, content, sourceMap) => {
-				if (!this.buildInfo.assets) this.buildInfo.assets = Object.create(null);
+				if (!this.buildInfo.assets) {
+					this.buildInfo.assets = Object.create(null);
+				}
 				this.buildInfo.assets[name] = this.createSourceForAsset(
 					name,
 					content,
@@ -191,7 +196,9 @@ class NormalModule extends Module {
 		};
 
 		compilation.hooks.normalModuleLoader.call(loaderContext, this);
-		if (options.loader) Object.assign(loaderContext, options.loader);
+		if (options.loader) {
+			Object.assign(loaderContext, options.loader);
+		}
 
 		return loaderContext;
 	}

package/lib/NormalModuleFactory.js

@@ -21,11 +21,18 @@ const cachedMerge = require("./util/cachedMerge");
 const EMPTY_RESOLVE_OPTIONS = {};
 
 const loaderToIdent = data => {
-	if (!data.options) return data.loader;
-	if (typeof data.options === "string") return data.loader + "?" + data.options;
-	if (typeof data.options !== "object")
+	if (!data.options) {
+		return data.loader;
+	}
+	if (typeof data.options === "string") {
+		return data.loader + "?" + data.options;
+	}
+	if (typeof data.options !== "object") {
 		throw new Error("loader options must be string or object");
-	if (data.ident) return data.loader + "??" + data.ident;
+	}
+	if (data.ident) {
+		return data.loader + "??" + data.ident;
+	}
 	return data.loader + "?" + JSON.stringify(data.options);
 };
 
@@ -252,16 +259,21 @@ class NormalModuleFactory extends Tapable {
 					const useLoadersPre = [];
 					for (const r of result) {
 						if (r.type === "use") {
-							if (r.enforce === "post" && !noPrePostAutoLoaders)
+							if (r.enforce === "post" && !noPrePostAutoLoaders) {
 								useLoadersPost.push(r.value);
-							else if (
+							} else if (
 								r.enforce === "pre" &&
 								!noPreAutoLoaders &&
 								!noPrePostAutoLoaders
-							)
+							) {
 								useLoadersPre.push(r.value);
-							else if (!r.enforce && !noAutoLoaders && !noPrePostAutoLoaders)
+							} else if (
+								!r.enforce &&
+								!noAutoLoaders &&
+								!noPrePostAutoLoaders
+							) {
 								useLoaders.push(r.value);
+							}
 						} else if (
 							typeof r.value === "object" &&
 							r.value !== null &&
@@ -428,8 +440,11 @@ class NormalModuleFactory extends Tapable {
 	getParser(type, parserOptions) {
 		let ident = type;
 		if (parserOptions) {
-			if (parserOptions.ident) ident = `${type}|${parserOptions.ident}`;
-			else ident = JSON.stringify([type, parserOptions]);
+			if (parserOptions.ident) {
+				ident = `${type}|${parserOptions.ident}`;
+			} else {
+				ident = JSON.stringify([type, parserOptions]);
+			}
 		}
 		if (ident in this.parserCache) {
 			return this.parserCache[ident];
@@ -449,8 +464,11 @@ class NormalModuleFactory extends Tapable {
 	getGenerator(type, generatorOptions) {
 		let ident = type;
 		if (generatorOptions) {
-			if (generatorOptions.ident) ident = `${type}|${generatorOptions.ident}`;
-			else ident = JSON.stringify([type, generatorOptions]);
+			if (generatorOptions.ident) {
+				ident = `${type}|${generatorOptions.ident}`;
+			} else {
+				ident = JSON.stringify([type, generatorOptions]);
+			}
 		}
 		if (ident in this.generatorCache) {
 			return this.generatorCache[ident];

package/lib/OptionsDefaulter.js

@@ -36,8 +36,9 @@ class OptionsDefaulter {
 		for (let name in this.defaults) {
 			switch (this.config[name]) {
 				case undefined:
-					if (getProperty(options, name) === undefined)
+					if (getProperty(options, name) === undefined) {
 						setProperty(options, name, this.defaults[name]);
+					}
 					break;
 				case "call":
 					setProperty(
@@ -47,12 +48,15 @@ class OptionsDefaulter {
 					);
 					break;
 				case "make":
-					if (getProperty(options, name) === undefined)
+					if (getProperty(options, name) === undefined) {
 						setProperty(options, name, this.defaults[name].call(this, options));
+					}
 					break;
 				case "append": {
 					let oldValue = getProperty(options, name);
-					if (!Array.isArray(oldValue)) oldValue = [];
+					if (!Array.isArray(oldValue)) {
+						oldValue = [];
+					}
 					oldValue.push(...this.defaults[name]);
 					setProperty(options, name, oldValue);
 					break;