webpack 4.10.1 → 4.10.2

package/lib/WebpackOptionsDefaulter.js

@@ -136,10 +136,11 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 			}
 		});
 		this.set("output.devtoolNamespace", "make", options => {
-			if (Array.isArray(options.output.library))
+			if (Array.isArray(options.output.library)) {
 				return options.output.library.join(".");
-			else if (typeof options.output.library === "object")
+			} else if (typeof options.output.library === "object") {
 				return options.output.library.root || "";
+			}
 			return options.output.library || "";
 		});
 		this.set("output.libraryTarget", "var");
@@ -305,9 +306,11 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		this.set("resolve.extensions", [".wasm", ".mjs", ".js", ".json"]);
 		this.set("resolve.mainFiles", ["index"]);
 		this.set("resolve.aliasFields", "make", options => {
-			if (options.target === "web" || options.target === "webworker")
+			if (options.target === "web" || options.target === "webworker") {
 				return ["browser"];
-			else return [];
+			} else {
+				return [];
+			}
 		});
 		this.set("resolve.mainFields", "make", options => {
 			if (

package/lib/WebpackOptionsValidationError.js

@@ -30,15 +30,23 @@ const getSchemaPartText = (schemaPart, additionalPath) => {
 			if (inner) schemaPart = inner;
 		}
 	}
-	while (schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref);
+	while (schemaPart.$ref) {
+		schemaPart = getSchemaPart(schemaPart.$ref);
+	}
 	let schemaText = WebpackOptionsValidationError.formatSchema(schemaPart);
-	if (schemaPart.description) schemaText += `\n-> ${schemaPart.description}`;
+	if (schemaPart.description) {
+		schemaText += `\n-> ${schemaPart.description}`;
+	}
 	return schemaText;
 };
 
 const getSchemaPartDescription = schemaPart => {
-	while (schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref);
-	if (schemaPart.description) return `\n-> ${schemaPart.description}`;
+	while (schemaPart.$ref) {
+		schemaPart = getSchemaPart(schemaPart.$ref);
+	}
+	if (schemaPart.description) {
+		return `\n-> ${schemaPart.description}`;
+	}
 	return "";
 };
 
@@ -87,12 +95,15 @@ class WebpackOptionsValidationError extends WebpackError {
 		prevSchemas = prevSchemas || [];
 
 		const formatInnerSchema = (innerSchema, addSelf) => {
-			if (!addSelf)
+			if (!addSelf) {
 				return WebpackOptionsValidationError.formatSchema(
 					innerSchema,
 					prevSchemas
 				);
-			if (prevSchemas.includes(innerSchema)) return "(recursive)";
+			}
+			if (prevSchemas.includes(innerSchema)) {
+				return "(recursive)";
+			}
 			return WebpackOptionsValidationError.formatSchema(
 				innerSchema,
 				prevSchemas.concat(schema)
@@ -100,15 +111,21 @@ class WebpackOptionsValidationError extends WebpackError {
 		};
 
 		if (schema.type === "string") {
-			if (schema.minLength === 1) return "non-empty string";
-			else if (schema.minLength > 1)
+			if (schema.minLength === 1) {
+				return "non-empty string";
+			}
+			if (schema.minLength > 1) {
 				return `string (min length ${schema.minLength})`;
+			}
 			return "string";
-		} else if (schema.type === "boolean") {
+		}
+		if (schema.type === "boolean") {
 			return "boolean";
-		} else if (schema.type === "number") {
+		}
+		if (schema.type === "number") {
 			return "number";
-		} else if (schema.type === "object") {
+		}
+		if (schema.type === "object") {
 			if (schema.properties) {
 				const required = schema.required || [];
 				return `object { ${Object.keys(schema.properties)
@@ -125,7 +142,8 @@ class WebpackOptionsValidationError extends WebpackError {
 				)} }`;
 			}
 			return "object";
-		} else if (schema.type === "array") {
+		}
+		if (schema.type === "array") {
 			return `[${formatInnerSchema(schema.items)}]`;
 		}
 
@@ -135,12 +153,22 @@ class WebpackOptionsValidationError extends WebpackError {
 			case "RegExp":
 				return "RegExp";
 		}
-		if (schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true);
-		if (schema.allOf) return schema.allOf.map(formatInnerSchema).join(" & ");
-		if (schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(" | ");
-		if (schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(" | ");
-		if (schema.enum)
+
+		if (schema.$ref) {
+			return formatInnerSchema(getSchemaPart(schema.$ref), true);
+		}
+		if (schema.allOf) {
+			return schema.allOf.map(formatInnerSchema).join(" & ");
+		}
+		if (schema.oneOf) {
+			return schema.oneOf.map(formatInnerSchema).join(" | ");
+		}
+		if (schema.anyOf) {
+			return schema.anyOf.map(formatInnerSchema).join(" | ");
+		}
+		if (schema.enum) {
 			return schema.enum.map(item => JSON.stringify(item)).join(" | ");
+		}
 		return JSON.stringify(schema, null, 2);
 	}
 
@@ -283,14 +311,15 @@ class WebpackOptionsValidationError extends WebpackError {
 			err.keyword === "minItems" ||
 			err.keyword === "minProperties"
 		) {
-			if (err.params.limit === 1)
+			if (err.params.limit === 1) {
 				return `${dataPath} should not be empty.${getSchemaPartDescription(
 					err.parentSchema
 				)}`;
-			else
+			} else {
 				return `${dataPath} ${err.message}${getSchemaPartDescription(
 					err.parentSchema
 				)}`;
+			}
 		} else if (err.keyword === "absolutePath") {
 			const baseMessage = `${dataPath}: ${
 				err.message

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -215,11 +215,14 @@ class AMDDefineDependencyParserPlugin {
 		let fnParams = null;
 		let fnParamsOffset = 0;
 		if (fn) {
-			if (isUnboundFunctionExpression(fn)) fnParams = fn.params;
-			else if (isBoundFunctionExpression(fn)) {
+			if (isUnboundFunctionExpression(fn)) {
+				fnParams = fn.params;
+			} else if (isBoundFunctionExpression(fn)) {
 				fnParams = fn.callee.object.params;
 				fnParamsOffset = fn.arguments.length - 1;
-				if (fnParamsOffset < 0) fnParamsOffset = 0;
+				if (fnParamsOffset < 0) {
+					fnParamsOffset = 0;
+				}
 			}
 		}
 		let fnRenames = parser.scope.renames.createChild();
@@ -234,7 +237,7 @@ class AMDDefineDependencyParserPlugin {
 				namedModule
 			);
 			if (!result) return;
-			if (fnParams)
+			if (fnParams) {
 				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
 					if (identifiers[idx]) {
 						fnRenames.set(param.name, identifiers[idx]);
@@ -242,9 +245,10 @@ class AMDDefineDependencyParserPlugin {
 					}
 					return true;
 				});
+			}
 		} else {
 			const identifiers = ["require", "exports", "module"];
-			if (fnParams)
+			if (fnParams) {
 				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
 					if (identifiers[idx]) {
 						fnRenames.set(param.name, identifiers[idx]);
@@ -252,6 +256,7 @@ class AMDDefineDependencyParserPlugin {
 					}
 					return true;
 				});
+			}
 		}
 		let inTry;
 		if (fn && isUnboundFunctionExpression(fn)) {
@@ -274,12 +279,16 @@ class AMDDefineDependencyParserPlugin {
 				() => {
 					parser.scope.renames = fnRenames;
 					parser.scope.inTry = inTry;
-					if (fn.callee.object.body.type === "BlockStatement")
+					if (fn.callee.object.body.type === "BlockStatement") {
 						parser.walkStatement(fn.callee.object.body);
-					else parser.walkExpression(fn.callee.object.body);
+					} else {
+						parser.walkExpression(fn.callee.object.body);
+					}
 				}
 			);
-			if (fn.arguments) parser.walkExpressions(fn.arguments);
+			if (fn.arguments) {
+				parser.walkExpressions(fn.arguments);
+			}
 		} else if (fn || obj) {
 			parser.walkExpression(fn || obj);
 		}

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -30,9 +30,11 @@ class AMDRequireDependenciesBlockParserPlugin {
 					return !["require", "module", "exports"].includes(i.name);
 				}),
 				() => {
-					if (fnData.fn.body.type === "BlockStatement")
+					if (fnData.fn.body.type === "BlockStatement") {
 						parser.walkStatement(fnData.fn.body);
-					else parser.walkExpression(fnData.fn.body);
+					} else {
+						parser.walkExpression(fnData.fn.body);
+					}
 				}
 			);
 			parser.walkExpressions(fnData.expressions);
@@ -212,7 +214,7 @@ class AMDRequireDependenciesBlockParserPlugin {
 				if (!result) {
 					dep = new UnsupportedDependency("unsupported", expr.range);
 					old.addDependency(dep);
-					if (parser.state.module)
+					if (parser.state.module) {
 						parser.state.module.errors.push(
 							new UnsupportedFeatureWarning(
 								parser.state.module,
@@ -220,6 +222,7 @@ class AMDRequireDependenciesBlockParserPlugin {
 									expr.loc.start.line
 							)
 						);
+					}
 					dep = null;
 					return true;
 				}

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -58,14 +58,16 @@ module.exports = class HarmonyDetectionParserPlugin {
 
 		const skipInHarmony = () => {
 			const module = parser.state.module;
-			if (module && module.buildMeta && module.buildMeta.exportsType)
+			if (module && module.buildMeta && module.buildMeta.exportsType) {
 				return true;
+			}
 		};
 
 		const nullInHarmony = () => {
 			const module = parser.state.module;
-			if (module && module.buildMeta && module.buildMeta.exportsType)
+			if (module && module.buildMeta && module.buildMeta.exportsType) {
 				return null;
+			}
 		};
 
 		const nonHarmonyIdentifiers = ["define", "exports"];

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -255,8 +255,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				otherImportedModule &&
 				Array.isArray(otherImportedModule.buildMeta.providedExports)
 			) {
-				for (const exportName of otherImportedModule.buildMeta.providedExports)
+				for (const exportName of otherImportedModule.buildMeta
+					.providedExports) {
 					result.add(exportName);
+				}
 			}
 		}
 		return result;
@@ -563,12 +565,14 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 				// Filter out exports which are defined by other exports
 				// and filter out default export because it cannot be reexported with *
-				if (activeExports.size > 0)
+				if (activeExports.size > 0) {
 					content +=
 						"if(" +
 						JSON.stringify(Array.from(activeExports).concat("default")) +
 						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
-				else content += "if(__WEBPACK_IMPORT_KEY__ !== 'default') ";
+				} else {
+					content += "if(__WEBPACK_IMPORT_KEY__ !== 'default') ";
+				}
 				const exportsName = dep.originModule.exportsArgument;
 				return (
 					content +

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -42,8 +42,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			(statement, source, id, name) => {
 				parser.scope.definitions.delete(name);
 				parser.scope.renames.set(name, "imported var");
-				if (!parser.state.harmonySpecifier)
+				if (!parser.state.harmonySpecifier) {
 					parser.state.harmonySpecifier = new Map();
+				}
 				parser.state.harmonySpecifier.set(name, {
 					source,
 					id,
@@ -152,16 +153,18 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				return true;
 			});
 		// TODO webpack 5: refactor this, no custom hooks
-		if (!parser.hooks.hotAcceptCallback)
+		if (!parser.hooks.hotAcceptCallback) {
 			parser.hooks.hotAcceptCallback = new SyncBailHook([
 				"expression",
 				"requests"
 			]);
-		if (!parser.hooks.hotAcceptWithoutCallback)
+		}
+		if (!parser.hooks.hotAcceptWithoutCallback) {
 			parser.hooks.hotAcceptWithoutCallback = new SyncBailHook([
 				"expression",
 				"requests"
 			]);
+		}
 		parser.hooks.hotAcceptCallback.tap(
 			"HarmonyImportDependencyParserPlugin",
 			(expr, requests) => {

package/lib/dependencies/ImportParserPlugin.js

@@ -18,10 +18,11 @@ class ImportParserPlugin {
 
 	apply(parser) {
 		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
-			if (expr.arguments.length !== 1)
+			if (expr.arguments.length !== 1) {
 				throw new Error(
 					"Incorrect number of arguments provided to 'import(module: string) -> Promise'."
 				);
+			}
 
 			const param = parser.evaluateExpression(expr.arguments[0]);
 

package/lib/dependencies/LoaderPlugin.js

@@ -28,7 +28,7 @@ class LoaderPlugin {
 						const factory = compilation.dependencyFactories.get(
 							dep.constructor
 						);
-						if (factory === undefined)
+						if (factory === undefined) {
 							return callback(
 								new Error(
 									`No module factory available for dependency type: ${
@@ -36,6 +36,7 @@ class LoaderPlugin {
 									}`
 								)
 							);
+						}
 						compilation.semaphore.release();
 						compilation.addModuleDependencies(
 							module,
@@ -50,16 +51,20 @@ class LoaderPlugin {
 							true,
 							err => {
 								compilation.semaphore.acquire(() => {
-									if (err) return callback(err);
-
-									if (!dep.module)
+									if (err) {
+										return callback(err);
+									}
+									if (!dep.module) {
 										return callback(new Error("Cannot load the module"));
-
-									if (dep.module.error) return callback(dep.module.error);
-									if (!dep.module._source)
+									}
+									if (dep.module.error) {
+										return callback(dep.module.error);
+									}
+									if (!dep.module._source) {
 										throw new Error(
 											"The module created for a LoaderDependency must have a property _source"
 										);
+									}
 									let source, map;
 									const moduleSource = dep.module._source;
 									if (moduleSource.sourceAndMap) {

package/lib/dependencies/LocalModulesHelpers.js

@@ -10,21 +10,26 @@ const LocalModulesHelpers = exports;
 const lookup = (parent, mod) => {
 	if (mod.charAt(0) !== ".") return mod;
 
-	var path = parent.split("/"),
-		segs = mod.split("/");
+	var path = parent.split("/");
+	var segs = mod.split("/");
 	path.pop();
 
 	for (let i = 0; i < segs.length; i++) {
 		const seg = segs[i];
-		if (seg === "..") path.pop();
-		else if (seg !== ".") path.push(seg);
+		if (seg === "..") {
+			path.pop();
+		} else if (seg !== ".") {
+			path.push(seg);
+		}
 	}
 
 	return path.join("/");
 };
 
 LocalModulesHelpers.addLocalModule = (state, name) => {
-	if (!state.localModules) state.localModules = [];
+	if (!state.localModules) {
+		state.localModules = [];
+	}
 	const m = new LocalModule(state.module, name, state.localModules.length);
 	state.localModules.push(m);
 	return m;
@@ -37,7 +42,9 @@ LocalModulesHelpers.getLocalModule = (state, name, namedModule) => {
 		name = lookup(namedModule, name);
 	}
 	for (let i = 0; i < state.localModules.length; i++) {
-		if (state.localModules[i].name === name) return state.localModules[i];
+		if (state.localModules[i].name === name) {
+			return state.localModules[i];
+		}
 	}
 	return null;
 };

package/lib/dependencies/RequireContextPlugin.js

@@ -11,10 +11,12 @@ const RequireContextDependencyParserPlugin = require("./RequireContextDependency
 
 class RequireContextPlugin {
 	constructor(modulesDirectories, extensions, mainFiles) {
-		if (!Array.isArray(modulesDirectories))
+		if (!Array.isArray(modulesDirectories)) {
 			throw new Error("modulesDirectories must be an array");
-		if (!Array.isArray(extensions))
+		}
+		if (!Array.isArray(extensions)) {
 			throw new Error("extensions must be an array");
+		}
 		this.modulesDirectories = modulesDirectories;
 		this.extensions = extensions;
 		this.mainFiles = mainFiles;

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -86,9 +86,11 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 								return;
 							}
 							if (successExpression) {
-								if (successExpression.fn.body.type === "BlockStatement")
+								if (successExpression.fn.body.type === "BlockStatement") {
 									parser.walkStatement(successExpression.fn.body);
-								else parser.walkExpression(successExpression.fn.body);
+								} else {
+									parser.walkExpression(successExpression.fn.body);
+								}
 							}
 							old.addBlock(dep);
 						} finally {
@@ -98,9 +100,11 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 							parser.walkExpression(successExpressionArg);
 						}
 						if (errorExpression) {
-							if (errorExpression.fn.body.type === "BlockStatement")
+							if (errorExpression.fn.body.type === "BlockStatement") {
 								parser.walkStatement(errorExpression.fn.body);
-							else parser.walkExpression(errorExpression.fn.body);
+							} else {
+								parser.walkExpression(errorExpression.fn.body);
+							}
 						} else if (errorExpressionArg) {
 							parser.walkExpression(errorExpressionArg);
 						}

package/lib/formatLocation.js

@@ -14,11 +14,15 @@ const formatPosition = pos => {
 		case "number":
 			return `${pos}`;
 		case "object":
-			if (typeof pos.line === "number" && typeof pos.column === "number")
+			if (typeof pos.line === "number" && typeof pos.column === "number") {
 				return `${pos.line}:${pos.column}`;
-			else if (typeof pos.line === "number") return `${pos.line}:?`;
-			else if (typeof pos.index === "number") return `+${pos.index}`;
-			else return "";
+			} else if (typeof pos.line === "number") {
+				return `${pos.line}:?`;
+			} else if (typeof pos.index === "number") {
+				return `+${pos.index}`;
+			} else {
+				return "";
+			}
 		default:
 			return "";
 	}
@@ -39,11 +43,15 @@ const formatLocation = loc => {
 					typeof loc.end.line === "number" &&
 					typeof loc.end.column === "number" &&
 					loc.start.line === loc.end.line
-				)
+				) {
 					return `${formatPosition(loc.start)}-${loc.end.column}`;
-				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+				} else {
+					return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+				}
+			}
+			if (loc.start) {
+				return formatPosition(loc.start);
 			}
-			if (loc.start) return formatPosition(loc.start);
 			return formatPosition(loc);
 		default:
 			return "";

package/lib/node/NodeMainTemplateAsync.runtime.js

@@ -10,7 +10,7 @@ module.exports = function() {
 		require("fs").readFile(filename, "utf-8", function(err, content) {
 			if (err) {
 				if ($require$.onError) return $require$.oe(err);
-				else throw err;
+				throw err;
 			}
 			var chunk = {};
 			require("vm").runInThisContext(

package/lib/node/NodeMainTemplatePlugin.js

@@ -116,10 +116,11 @@ module.exports = class NodeMainTemplatePlugin {
 													hashWithLength: length => {
 														const shortChunkHashMap = {};
 														for (const chunkId of Object.keys(chunkMaps.hash)) {
-															if (typeof chunkMaps.hash[chunkId] === "string")
+															if (typeof chunkMaps.hash[chunkId] === "string") {
 																shortChunkHashMap[chunkId] = chunkMaps.hash[
 																	chunkId
 																].substr(0, length);
+															}
 														}
 														return `" + ${JSON.stringify(
 															shortChunkHashMap
@@ -201,10 +202,11 @@ module.exports = class NodeMainTemplatePlugin {
 								hashWithLength: length => {
 									const shortChunkHashMap = {};
 									for (const chunkId of Object.keys(chunkMaps.hash)) {
-										if (typeof chunkMaps.hash[chunkId] === "string")
+										if (typeof chunkMaps.hash[chunkId] === "string") {
 											shortChunkHashMap[chunkId] = chunkMaps.hash[
 												chunkId
 											].substr(0, length);
+										}
 									}
 									return `" + ${JSON.stringify(
 										shortChunkHashMap
@@ -278,11 +280,12 @@ module.exports = class NodeMainTemplatePlugin {
 							hashWithLength: length => {
 								const shortChunkHashMap = {};
 								for (const chunkId of Object.keys(chunkMaps.hash)) {
-									if (typeof chunkMaps.hash[chunkId] === "string")
+									if (typeof chunkMaps.hash[chunkId] === "string") {
 										shortChunkHashMap[chunkId] = chunkMaps.hash[chunkId].substr(
 											0,
 											length
 										);
+									}
 								}
 								return `" + ${JSON.stringify(shortChunkHashMap)}[chunkId] + "`;
 							},

package/lib/node/NodeSourcePlugin.js

@@ -13,22 +13,26 @@ module.exports = class NodeSourcePlugin {
 	}
 	apply(compiler) {
 		const options = this.options;
-		if (options === false)
+		if (options === false) {
 			// allow single kill switch to turn off this plugin
 			return;
+		}
 
 		const getPathToModule = (module, type) => {
 			if (type === true || (type === undefined && nodeLibsBrowser[module])) {
-				if (!nodeLibsBrowser[module])
+				if (!nodeLibsBrowser[module]) {
 					throw new Error(
 						`No browser version for node.js core module ${module} available`
 					);
+				}
 				return nodeLibsBrowser[module];
 			} else if (type === "mock") {
 				return require.resolve(`node-libs-browser/mock/${module}`);
 			} else if (type === "empty") {
 				return require.resolve("node-libs-browser/mock/empty");
-			} else return module;
+			} else {
+				return module;
+			}
 		};
 
 		const addExpression = (parser, name, module, type, suffix) => {
@@ -58,9 +62,9 @@ module.exports = class NodeSourcePlugin {
 					if (parserOptions.node === false) return;
 
 					let localOptions = options;
-					if (parserOptions.node)
+					if (parserOptions.node) {
 						localOptions = Object.assign({}, localOptions, parserOptions.node);
-
+					}
 					if (localOptions.global) {
 						parser.hooks.expression
 							.for("global")