webpack 4.10.1 → 4.12.0

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/ModuleNotFoundError.js

@@ -1,26 +1,23 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const WebpackError = require("./WebpackError");
-
-class ModuleNotFoundError extends WebpackError {
-	constructor(module, err, dependencies) {
-		super();
-
-		this.name = "ModuleNotFoundError";
-		this.message = "Module not found: " + err;
-		this.details = err.details;
-		this.missing = err.missing;
-		this.module = module;
-		this.origin = module;
-		this.dependencies = dependencies;
-		this.error = err;
-
-		Error.captureStackTrace(this, this.constructor);
-	}
-}
-
-module.exports = ModuleNotFoundError;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class ModuleNotFoundError extends WebpackError {
+	constructor(module, err) {
+		super("Module not found: " + err);
+
+		this.name = "ModuleNotFoundError";
+		this.details = err.details;
+		this.missing = err.missing;
+		this.module = module;
+		this.error = err;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = ModuleNotFoundError;

package/lib/ModuleParseError.js

@@ -6,14 +6,18 @@
 
 const WebpackError = require("./WebpackError");
 
+/** @typedef {import("./Module")} Module */
+
 class ModuleParseError extends WebpackError {
+	/**
+	 * @param {Module} module the errored module
+	 * @param {string} source source code
+	 * @param {Error&any} err the parse error
+	 */
 	constructor(module, source, err) {
-		super();
-
-		this.name = "ModuleParseError";
-		this.message = "Module parse failed: " + err.message;
-		this.message +=
-			"\nYou may need an appropriate loader to handle this file type.";
+		let message = "Module parse failed: " + err.message;
+		let loc = undefined;
+		message += "\nYou may need an appropriate loader to handle this file type.";
 		if (
 			err.loc &&
 			typeof err.loc === "object" &&
@@ -22,19 +26,28 @@ class ModuleParseError extends WebpackError {
 			var lineNumber = err.loc.line;
 			if (/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)) {
 				// binary file
-				this.message += "\n(Source code omitted for this binary file)";
+				message += "\n(Source code omitted for this binary file)";
 			} else {
-				source = source.split("\n");
-				this.message +=
-					"\n| " +
-					source
-						.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-						.join("\n| ");
+				const sourceLines = source.split("\n");
+				const start = Math.max(0, lineNumber - 3);
+				const linesBefore = sourceLines.slice(start, lineNumber - 1);
+				const theLine = sourceLines[lineNumber - 1];
+				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+				message +=
+					linesBefore.map(l => `\n| ${l}`).join("") +
+					`\n> ${theLine}` +
+					linesAfter.map(l => `\n| ${l}`).join("");
 			}
+			loc = err.loc;
 		} else {
-			this.message += "\n" + err.stack;
+			message += "\n" + err.stack;
 		}
+
+		super(message);
+
+		this.name = "ModuleParseError";
 		this.module = module;
+		this.loc = loc;
 		this.error = err;
 
 		Error.captureStackTrace(this, this.constructor);

package/lib/ModuleWarning.js

@@ -8,15 +8,21 @@ const WebpackError = require("./WebpackError");
 const { cleanUp } = require("./ErrorHelpers");
 
 class ModuleWarning extends WebpackError {
-	constructor(module, warning) {
-		super();
-
+	constructor(module, warning, { from = null } = {}) {
+		let message = "Module Warning";
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
+		}
+		if (warning && typeof warning === "object" && warning.message) {
+			message += warning.message;
+		} else if (warning) {
+			message += warning;
+		}
+		super(message);
 		this.name = "ModuleWarning";
 		this.module = module;
-		this.message =
-			warning && typeof warning === "object" && warning.message
-				? warning.message
-				: warning;
 		this.warning = warning;
 		this.details =
 			warning && typeof warning === "object" && warning.stack

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

@@ -43,9 +43,18 @@ const contextify = (context, request) => {
 		.split("!")
 		.map(r => {
 			const splitPath = r.split("?");
-			splitPath[0] = path.relative(context, splitPath[0]);
-			if (path.sep === "\\") splitPath[0] = splitPath[0].replace(/\\/g, "/");
-			if (splitPath[0].indexOf("../") !== 0) splitPath[0] = "./" + splitPath[0];
+			if (/^[a-zA-Z]:\\/.test(splitPath[0])) {
+				splitPath[0] = path.win32.relative(context, splitPath[0]);
+				if (!/^[a-zA-Z]:\\/.test(splitPath[0])) {
+					splitPath[0] = splitPath[0].replace(/\\/g, "/");
+				}
+			}
+			if (/^\//.test(splitPath[0])) {
+				splitPath[0] = path.posix.relative(context, splitPath[0]);
+			}
+			if (!/^(\.\.\/|\/|[a-zA-Z]:\\)/.test(splitPath[0])) {
+				splitPath[0] = "./" + splitPath[0];
+			}
 			return splitPath.join("?");
 		})
 		.join("!");
@@ -76,6 +85,7 @@ class NormalModule extends Module {
 		rawRequest,
 		loaders,
 		resource,
+		matchResource,
 		parser,
 		generator,
 		resolveOptions
@@ -90,6 +100,7 @@ class NormalModule extends Module {
 		this.parser = parser;
 		this.generator = generator;
 		this.resource = resource;
+		this.matchResource = matchResource;
 		this.loaders = loaders;
 		if (resolveOptions !== undefined) this.resolveOptions = resolveOptions;
 
@@ -123,16 +134,21 @@ class NormalModule extends Module {
 	}
 
 	nameForCondition() {
-		const idx = this.resource.indexOf("?");
-		if (idx >= 0) return this.resource.substr(0, idx);
-		return this.resource;
+		const resource = this.matchResource || this.resource;
+		const idx = resource.indexOf("?");
+		if (idx >= 0) return resource.substr(0, idx);
+		return resource;
 	}
 
 	updateCacheModule(module) {
+		this.type = module.type;
+		this.request = module.request;
 		this.userRequest = module.userRequest;
+		this.rawRequest = module.rawRequest;
 		this.parser = module.parser;
 		this.generator = module.generator;
 		this.resource = module.resource;
+		this.matchResource = module.matchResource;
 		this.loaders = module.loaders;
 		this.resolveOptions = module.resolveOptions;
 	}
@@ -150,16 +166,30 @@ class NormalModule extends Module {
 	}
 
 	createLoaderContext(resolver, options, compilation, fs) {
+		const requestShortener = compilation.runtimeTemplate.requestShortener;
 		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));
+				}
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				this.warnings.push(
+					new ModuleWarning(this, warning, {
+						from: requestShortener.shorten(currentLoader.loader)
+					})
+				);
 			},
 			emitError: error => {
-				if (!(error instanceof Error)) error = new NonErrorEmittedError(error);
-				this.errors.push(new ModuleError(this, error));
+				if (!(error instanceof Error)) {
+					error = new NonErrorEmittedError(error);
+				}
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				this.errors.push(
+					new ModuleError(this, error, {
+						from: requestShortener.shorten(currentLoader.loader)
+					})
+				);
 			},
 			exec: (code, filename) => {
 				// @ts-ignore Argument of type 'this' is not assignable to parameter of type 'Module'.
@@ -174,7 +204,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,11 +223,26 @@ 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;
 	}
 
+	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
+		if (
+			this.loaders &&
+			this.loaders.length &&
+			index < this.loaders.length &&
+			index >= 0 &&
+			this.loaders[index]
+		) {
+			return this.loaders[index];
+		}
+		return null;
+	}
+
 	createSource(source, resourceBuffer, sourceMap) {
 		// if there is no identifier return raw source
 		if (!this.identifier) {
@@ -249,7 +296,17 @@ class NormalModule extends Module {
 				}
 
 				if (err) {
-					const error = new ModuleBuildError(this, err);
+					if (!(err instanceof Error)) {
+						err = new NonErrorEmittedError(err);
+					}
+					const currentLoader = this.getCurrentLoader(loaderContext);
+					const error = new ModuleBuildError(this, err, {
+						from:
+							currentLoader &&
+							compilation.runtimeTemplate.requestShortener.shorten(
+								currentLoader.loader
+							)
+					});
 					return callback(error);
 				}
 
@@ -259,10 +316,17 @@ class NormalModule extends Module {
 				const extraInfo = result.result.length >= 2 ? result.result[2] : null;
 
 				if (!Buffer.isBuffer(source) && typeof source !== "string") {
-					const error = new ModuleBuildError(
-						this,
-						new Error("Final loader didn't return a Buffer or String")
+					const currentLoader = this.getCurrentLoader(loaderContext, 0);
+					const err = new Error(
+						`Final loader (${
+							currentLoader
+								? compilation.runtimeTemplate.requestShortener.shorten(
+										currentLoader.loader
+								  )
+								: "unknown"
+						}) didn't return a Buffer or String`
 					);
+					const error = new ModuleBuildError(this, err);
 					return callback(error);
 				}
 

package/lib/NormalModuleFactory.js

@@ -4,6 +4,7 @@
  */
 "use strict";
 
+const path = require("path");
 const asyncLib = require("neo-async");
 const {
 	Tapable,
@@ -20,12 +21,21 @@ const cachedMerge = require("./util/cachedMerge");
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
+const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
+
 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);
 };
 
@@ -151,19 +161,33 @@ class NormalModuleFactory extends Tapable {
 			const context = data.context;
 			const request = data.request;
 
-			const noPreAutoLoaders = request.startsWith("-!");
-			const noAutoLoaders = noPreAutoLoaders || request.startsWith("!");
-			const noPrePostAutoLoaders = request.startsWith("!!");
-			let elements = request
+			const loaderResolver = this.getResolver("loader");
+			const normalResolver = this.getResolver("normal", data.resolveOptions);
+
+			let matchResource = undefined;
+			let requestWithoutMatchResource = request;
+			const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
+			if (matchResourceMatch) {
+				matchResource = matchResourceMatch[1];
+				if (/^\.\.?\//.test(matchResource)) {
+					matchResource = path.join(context, matchResource);
+				}
+				requestWithoutMatchResource = request.substr(
+					matchResourceMatch[0].length
+				);
+			}
+
+			const noPreAutoLoaders = requestWithoutMatchResource.startsWith("-!");
+			const noAutoLoaders =
+				noPreAutoLoaders || requestWithoutMatchResource.startsWith("!");
+			const noPrePostAutoLoaders = requestWithoutMatchResource.startsWith("!!");
+			let elements = requestWithoutMatchResource
 				.replace(/^-?!+/, "")
 				.replace(/!!+/g, "!")
 				.split("!");
 			let resource = elements.pop();
 			elements = elements.map(identToLoaderRequest);
 
-			const loaderResolver = this.getResolver("loader");
-			const normalResolver = this.getResolver("normal", data.resolveOptions);
-
 			asyncLib.parallel(
 				[
 					callback =>
@@ -227,12 +251,15 @@ class NormalModuleFactory extends Tapable {
 						);
 					}
 
-					const userRequest = loaders
-						.map(loaderToIdent)
-						.concat([resource])
-						.join("!");
+					const userRequest =
+						(matchResource !== undefined ? `${matchResource}!=!` : "") +
+						loaders
+							.map(loaderToIdent)
+							.concat([resource])
+							.join("!");
 
-					let resourcePath = resource;
+					let resourcePath =
+						matchResource !== undefined ? matchResource : resource;
 					let resourceQuery = "";
 					const queryIndex = resourcePath.indexOf("?");
 					if (queryIndex >= 0) {
@@ -242,6 +269,10 @@ class NormalModuleFactory extends Tapable {
 
 					const result = this.ruleSet.exec({
 						resource: resourcePath,
+						realResource:
+							matchResource !== undefined
+								? resource.replace(/\?.*/, "")
+								: resourcePath,
 						resourceQuery,
 						issuer: contextInfo.issuer,
 						compiler: contextInfo.compiler
@@ -252,16 +283,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 &&
@@ -314,6 +350,7 @@ class NormalModuleFactory extends Tapable {
 									rawRequest: request,
 									loaders,
 									resource,
+									matchResource,
 									resourceResolveData,
 									settings,
 									type,
@@ -428,8 +465,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 +489,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;