webpack 4.10.1 → 4.12.0

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 "";
 };
 
@@ -61,23 +69,23 @@ const indent = (str, prefix, firstLine) => {
 
 class WebpackOptionsValidationError extends WebpackError {
 	constructor(validationErrors) {
-		super();
+		super(
+			"Invalid configuration object. " +
+				"Webpack has been initialised using a configuration object that does not match the API schema.\n" +
+				validationErrors
+					.map(
+						err =>
+							" - " +
+							indent(
+								WebpackOptionsValidationError.formatValidationError(err),
+								"   ",
+								false
+							)
+					)
+					.join("\n")
+		);
 
 		this.name = "WebpackOptionsValidationError";
-		this.message =
-			"Invalid configuration object. " +
-			"Webpack has been initialised using a configuration object that does not match the API schema.\n" +
-			validationErrors
-				.map(
-					err =>
-						" - " +
-						indent(
-							WebpackOptionsValidationError.formatValidationError(err),
-							"   ",
-							false
-						)
-				)
-				.join("\n");
 		this.validationErrors = validationErrors;
 
 		Error.captureStackTrace(this, this.constructor);
@@ -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/debug/ProfilingPlugin.js

@@ -71,9 +71,18 @@ class Profiler {
 	}
 }
 
+/**
+ * @typedef {Object} Trace
+ * @description an object that wraps Tracer and Profiler with a counter
+ * @property {Tracer} trace instance of Tracer
+ * @property {number} counter Counter
+ * @property {Profiler} profiler instance of Profiler
+ * @property {Function} end the end function
+ */
+
 /**
  * @param {string} outputPath The location where to write the log.
- * @returns {{trace: ?,	counter: number, profiler: Profiler, end: Function}} The trace object
+ * @returns {Trace} The trace object
  */
 function createTrace(outputPath) {
 	const trace = new Tracer({
@@ -325,7 +334,7 @@ const makeInterceptorFor = (instance, tracer) => hookName => ({
 
 /**
  * @param {string} hookName Name of the hook to profile.
- * @param {Tracer} tracer Instance of tracer.
+ * @param {Trace} tracer The trace object.
  * @param {object} options Options for the profiled fn.
  * @param {string} options.name Plugin name
  * @param {string} options.type Plugin type (sync | async | promise)

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,14 +214,16 @@ 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,
 								"Cannot statically analyse 'require(…, …)' in line " +
-									expr.loc.start.line
+									expr.loc.start.line,
+								expr.loc
 							)
 						);
+					}
 					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

@@ -10,6 +10,7 @@ const ImportDependenciesBlock = require("./ImportDependenciesBlock");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
 
 class ImportParserPlugin {
 	constructor(options) {
@@ -18,10 +19,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]);
 
@@ -31,7 +33,26 @@ class ImportParserPlugin {
 			let exclude = null;
 			const groupOptions = {};
 
-			const importOptions = parser.getCommentOptions(expr.range);
+			const {
+				options: importOptions,
+				errors: commentErrors
+			} = parser.parseCommentOptions(expr.range);
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.warnings.push(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${
+								comment.value
+							}*/: ${e.message}`,
+							parser.state.module,
+							comment.loc
+						)
+					);
+				}
+			}
+
 			if (importOptions) {
 				if (typeof importOptions.webpackIgnore !== "undefined") {
 					if (typeof importOptions.webpackIgnore !== "boolean") {
@@ -40,7 +61,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackIgnore\` expected a boolean, but received: ${
 									importOptions.webpackIgnore
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					} else {
@@ -57,7 +79,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackChunkName\` expected a string, but received: ${
 									importOptions.webpackChunkName
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					} else {
@@ -71,7 +94,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackMode\` expected a string, but received: ${
 									importOptions.webpackMode
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					} else {
@@ -89,7 +113,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackPrefetch\` expected true or a number, but received: ${
 									importOptions.webpackPrefetch
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					}
@@ -105,7 +130,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackPreload\` expected true or a number, but received: ${
 									importOptions.webpackPreload
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					}
@@ -120,7 +146,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackInclude\` expected a regular expression, but received: ${
 									importOptions.webpackInclude
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					} else {
@@ -137,7 +164,8 @@ class ImportParserPlugin {
 								parser.state.module,
 								`\`webpackExclude\` expected a regular expression, but received: ${
 									importOptions.webpackExclude
-								}.`
+								}.`,
+								expr.loc
 							)
 						);
 					} else {
@@ -151,7 +179,8 @@ class ImportParserPlugin {
 					parser.state.module.warnings.push(
 						new UnsupportedFeatureWarning(
 							parser.state.module,
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`
+							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
 						)
 					);
 				}
@@ -194,7 +223,8 @@ class ImportParserPlugin {
 					parser.state.module.warnings.push(
 						new UnsupportedFeatureWarning(
 							parser.state.module,
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`
+							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
 						)
 					);
 					mode = "lazy";
@@ -229,4 +259,5 @@ class ImportParserPlugin {
 		});
 	}
 }
+
 module.exports = ImportParserPlugin;

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/dependencies/SystemPlugin.js

@@ -108,15 +108,15 @@ class SystemPlugin {
 
 class SystemImportDeprecationWarning extends WebpackError {
 	constructor(module, loc) {
-		super();
+		super(
+			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
+				"For more info visit https://webpack.js.org/guides/code-splitting/"
+		);
 
 		this.name = "SystemImportDeprecationWarning";
-		this.message =
-			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
-			"For more info visit https://webpack.js.org/guides/code-splitting/";
 
-		this.origin = this.module = module;
-		this.originLoc = loc;
+		this.module = module;
+		this.loc = loc;
 
 		Error.captureStackTrace(this, this.constructor);
 	}