webpack 4.36.1 → 4.39.1

package/lib/Compiler.js

@@ -27,6 +27,7 @@ const ResolverFactory = require("./ResolverFactory");
 const RequestShortener = require("./RequestShortener");
 const { makePathsRelative } = require("./util/identifier");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
+const { Logger } = require("./logging/Logger");
 
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
@@ -54,6 +55,8 @@ class Compiler extends Tapable {
 			run: new AsyncSeriesHook(["compiler"]),
 			/** @type {AsyncSeriesHook<Compilation>} */
 			emit: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<string, Buffer>} */
+			assetEmitted: new AsyncSeriesHook(["file", "content"]),
 			/** @type {AsyncSeriesHook<Compilation>} */
 			afterEmit: new AsyncSeriesHook(["compilation"]),
 
@@ -84,6 +87,9 @@ class Compiler extends Tapable {
 			/** @type {SyncHook} */
 			watchClose: new SyncHook([]),
 
+			/** @type {SyncBailHook<string, string, any[]>} */
+			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
+
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
 			/** @type {SyncHook} */
@@ -97,6 +103,8 @@ class Compiler extends Tapable {
 			/** @type {SyncBailHook<string, Entry>} */
 			entryOption: new SyncBailHook(["context", "entry"])
 		};
+		// TODO webpack 5 remove this
+		this.hooks.infrastructurelog = this.hooks.infrastructureLog;
 
 		this._pluginCompat.tap("Compiler", options => {
 			switch (options.name) {
@@ -137,6 +145,8 @@ class Compiler extends Tapable {
 		/** @type {ResolverFactory} */
 		this.resolverFactory = new ResolverFactory();
 
+		this.infrastructureLogger = undefined;
+
 		// TODO remove in webpack 5
 		this.resolvers = {
 			normal: {
@@ -196,6 +206,33 @@ class Compiler extends Tapable {
 		this._assetEmittingWrittenFiles = new Map();
 	}
 
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
+	getInfrastructureLogger(name) {
+		if (!name) {
+			throw new TypeError(
+				"Compiler.getInfrastructureLogger(name) called without a name"
+			);
+		}
+		return new Logger((type, args) => {
+			if (typeof name === "function") {
+				name = name();
+				if (!name) {
+					throw new TypeError(
+						"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+					);
+				}
+			}
+			if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+				if (this.infrastructureLogger !== undefined) {
+					this.infrastructureLogger(name, type, args);
+				}
+			}
+		});
+	}
+
 	watch(watchOptions, handler) {
 		if (this.running) return handler(new ConcurrentCompilationError());
 
@@ -397,7 +434,7 @@ class Compiler extends Tapable {
 										: targetFileGeneration + 1;
 								cacheEntry.writtenTo.set(targetPath, newGeneration);
 								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								callback();
+								this.hooks.assetEmitted.callAsync(file, content, callback);
 							});
 						} else {
 							if (source.existsAt === targetPath) {
@@ -412,7 +449,10 @@ class Compiler extends Tapable {
 
 							source.existsAt = targetPath;
 							source.emitted = true;
-							this.outputFileSystem.writeFile(targetPath, content, callback);
+							this.outputFileSystem.writeFile(targetPath, content, err => {
+								if (err) return callback(err);
+								this.hooks.assetEmitted.callAsync(file, content, callback);
+							});
 						}
 					};
 

package/lib/MultiCompiler.js

@@ -18,7 +18,10 @@ module.exports = class MultiCompiler extends Tapable {
 			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
 			run: new MultiHook(compilers.map(c => c.hooks.run)),
 			watchClose: new SyncHook([]),
-			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun))
+			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
+			infrastructureLog: new MultiHook(
+				compilers.map(c => c.hooks.infrastructureLog)
+			)
 		};
 		if (!Array.isArray(compilers)) {
 			compilers = Object.keys(compilers).map(name => {
@@ -90,6 +93,10 @@ module.exports = class MultiCompiler extends Tapable {
 		}
 	}
 
+	getInfrastructureLogger(name) {
+		return this.compilers[0].getInfrastructureLogger(name);
+	}
+
 	validateDependencies(callback) {
 		const edges = new Set();
 		const missing = [];

package/lib/NormalModule.js

@@ -147,16 +147,20 @@ class NormalModule extends Module {
 
 	createLoaderContext(resolver, options, compilation, fs) {
 		const requestShortener = compilation.runtimeTemplate.requestShortener;
+		const getCurrentLoaderName = () => {
+			const currentLoader = this.getCurrentLoader(loaderContext);
+			if (!currentLoader) return "(not in loader scope)";
+			return requestShortener.shorten(currentLoader.loader);
+		};
 		const loaderContext = {
 			version: 2,
 			emitWarning: warning => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
 				}
-				const currentLoader = this.getCurrentLoader(loaderContext);
 				this.warnings.push(
 					new ModuleWarning(this, warning, {
-						from: requestShortener.shorten(currentLoader.loader)
+						from: getCurrentLoaderName()
 					})
 				);
 			},
@@ -164,13 +168,20 @@ class NormalModule extends Module {
 				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)
+						from: getCurrentLoaderName()
 					})
 				);
 			},
+			getLogger: name => {
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				return compilation.getLogger(() =>
+					[currentLoader && currentLoader.loader, name, this.identifier()]
+						.filter(Boolean)
+						.join("|")
+				);
+			},
 			// TODO remove in webpack 5
 			exec: (code, filename) => {
 				// @ts-ignore Argument of type 'this' is not assignable to parameter of type 'Module'.

package/lib/ProgressPlugin.js

@@ -10,50 +10,14 @@ const schema = require("../schemas/plugins/ProgressPlugin.json");
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
 
-const createDefaultHandler = profile => {
-	let lineCaretPosition = 0;
-	let lastMessage = "";
+const createDefaultHandler = (profile, logger) => {
 	let lastState;
 	let lastStateTime;
 
 	const defaultHandler = (percentage, msg, ...args) => {
-		let state = msg;
-		const details = args.filter(v => v.length);
-		const maxLineLength = process.stderr.columns || Infinity;
-		if (percentage < 1) {
-			percentage = Math.floor(percentage * 100);
-			msg = `${percentage}% ${msg}`;
-			if (percentage < 100) {
-				msg = ` ${msg}`;
-			}
-			if (percentage < 10) {
-				msg = ` ${msg}`;
-			}
-
-			if (details.length) {
-				const maxTotalDetailsLength = maxLineLength - msg.length;
-				const totalDetailsLength = details.reduce(
-					(a, b) => a + b.length,
-					details.length // account for added space before each detail text
-				);
-				const maxDetailLength =
-					totalDetailsLength < maxTotalDetailsLength
-						? Infinity
-						: Math.floor(maxTotalDetailsLength / details.length);
-
-				for (let detail of details) {
-					if (!detail) continue;
-					if (detail.length + 1 > maxDetailLength) {
-						const truncatePrefix = "...";
-						detail = `${truncatePrefix}${detail.substr(
-							-(maxDetailLength - truncatePrefix.length - 1)
-						)}`;
-					}
-					msg += ` ${detail}`;
-				}
-			}
-		}
+		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
 		if (profile) {
+			let state = msg;
 			state = state.replace(/^\d+\/\d+\s+/, "");
 			if (percentage === 0) {
 				lastState = null;
@@ -61,33 +25,23 @@ const createDefaultHandler = profile => {
 			} else if (state !== lastState || percentage === 1) {
 				const now = Date.now();
 				if (lastState) {
-					const stateMsg = `${now - lastStateTime}ms ${lastState}`;
-					goToLineStart(stateMsg);
-					process.stderr.write(stateMsg + "\n");
-					lineCaretPosition = 0;
+					const diff = now - lastStateTime;
+					const stateMsg = `${diff}ms ${lastState}`;
+					if (diff > 1000) {
+						logger.warn(stateMsg);
+					} else if (diff > 10) {
+						logger.info(stateMsg);
+					} else if (diff > 0) {
+						logger.log(stateMsg);
+					} else {
+						logger.debug(stateMsg);
+					}
 				}
 				lastState = state;
 				lastStateTime = now;
 			}
 		}
-		if (lastMessage !== msg) {
-			goToLineStart(msg);
-			msg = msg.substring(0, maxLineLength);
-			process.stderr.write(msg);
-			lastMessage = msg;
-		}
-	};
-
-	const goToLineStart = nextMessage => {
-		let str = "";
-		for (; lineCaretPosition > nextMessage.length; lineCaretPosition--) {
-			str += "\b \b";
-		}
-		for (var i = 0; i < lineCaretPosition; i++) {
-			str += "\b";
-		}
-		lineCaretPosition = nextMessage.length;
-		if (str) process.stderr.write(str);
+		if (percentage === 1) logger.status();
 	};
 
 	return defaultHandler;
@@ -118,7 +72,12 @@ class ProgressPlugin {
 
 	apply(compiler) {
 		const { modulesCount } = this;
-		const handler = this.handler || createDefaultHandler(this.profile);
+		const handler =
+			this.handler ||
+			createDefaultHandler(
+				this.profile,
+				compiler.getInfrastructureLogger("webpack.Progress")
+			);
 		const showEntries = this.showEntries;
 		const showModules = this.showModules;
 		const showActiveModules = this.showActiveModules;
@@ -263,7 +222,6 @@ class ProgressPlugin {
 					recordModules: "record modules",
 					recordChunks: "record chunks",
 					beforeHash: "hashing",
-					contentHash: "content hashing",
 					afterHash: "after hashing",
 					recordHash: "record hash",
 					beforeModuleAssets: "module assets processing",

package/lib/ResolverFactory.js

@@ -25,20 +25,16 @@ module.exports = class ResolverFactory extends Tapable {
 			let match;
 			match = /^resolve-options (.+)$/.exec(options.name);
 			if (match) {
-				this.hooks.resolveOptions.tap(
-					match[1],
-					options.fn.name || "unnamed compat plugin",
-					options.fn
-				);
+				this.hooks.resolveOptions
+					.for(match[1])
+					.tap(options.fn.name || "unnamed compat plugin", options.fn);
 				return true;
 			}
 			match = /^resolver (.+)$/.exec(options.name);
 			if (match) {
-				this.hooks.resolver.tap(
-					match[1],
-					options.fn.name || "unnamed compat plugin",
-					options.fn
-				);
+				this.hooks.resolver
+					.for(match[1])
+					.tap(options.fn.name || "unnamed compat plugin", options.fn);
 				return true;
 			}
 		});

package/lib/SourceMapDevToolPlugin.js

@@ -49,27 +49,13 @@ const assetsCache = new WeakMap();
 /**
  * Creating {@link SourceMapTask} for given file
  * @param {string} file current compiled file
+ * @param {Source} asset the asset
  * @param {Chunk} chunk related chunk
  * @param {SourceMapDevToolPluginOptions} options source map options
  * @param {Compilation} compilation compilation instance
  * @returns {SourceMapTask | undefined} created task instance or `undefined`
  */
-const getTaskForFile = (file, chunk, options, compilation) => {
-	const asset = compilation.assets[file];
-	const cache = assetsCache.get(asset);
-	/**
-	 * If presented in cache, reassigns assets. Cache assets already have source maps.
-	 */
-	if (cache && cache.file === file) {
-		for (const cachedFile in cache.assets) {
-			compilation.assets[cachedFile] = cache.assets[cachedFile];
-			/**
-			 * Add file to chunk, if not presented there
-			 */
-			if (cachedFile !== file) chunk.files.push(cachedFile);
-		}
-		return;
-	}
+const getTaskForFile = (file, asset, chunk, options, compilation) => {
 	let source, sourceMap;
 	/**
 	 * Check if asset can build source map
@@ -189,13 +175,35 @@ class SourceMapDevToolPlugin {
 					reportProgress(0.0);
 					const tasks = [];
 					files.forEach(({ file, chunk }, idx) => {
+						const asset = compilation.assets[file];
+						const cache = assetsCache.get(asset);
+						/**
+						 * If presented in cache, reassigns assets. Cache assets already have source maps.
+						 */
+						if (cache && cache.file === file) {
+							for (const cachedFile in cache.assets) {
+								compilation.assets[cachedFile] = cache.assets[cachedFile];
+								/**
+								 * Add file to chunk, if not presented there
+								 */
+								if (cachedFile !== file) chunk.files.push(cachedFile);
+							}
+							return;
+						}
+
 						reportProgress(
 							(0.5 * idx) / files.length,
 							file,
 							"generate SourceMap"
 						);
 						/** @type {SourceMapTask | undefined} */
-						const task = getTaskForFile(file, chunk, options, compilation);
+						const task = getTaskForFile(
+							file,
+							asset,
+							chunk,
+							options,
+							compilation
+						);
 
 						if (task) {
 							const modules = task.sourceMap.sources.map(source => {

package/lib/Stats.js

@@ -9,6 +9,7 @@ const SizeFormatHelpers = require("./SizeFormatHelpers");
 const formatLocation = require("./formatLocation");
 const identifierUtils = require("./util/identifier");
 const compareLocations = require("./compareLocations");
+const { LogType } = require("./logging/Logger");
 
 const optionsOrFallback = (...args) => {
 	let optionValues = [];
@@ -198,6 +199,18 @@ class Stats {
 			options.publicPath,
 			!forToString
 		);
+		const showLogging = optionOrLocalFallback(
+			options.logging,
+			forToString ? "info" : true
+		);
+		const showLoggingTrace = optionOrLocalFallback(
+			options.loggingTrace,
+			!forToString
+		);
+		const loggingDebug = []
+			.concat(optionsOrFallback(options.loggingDebug, []))
+			.map(testAgainstGivenOption);
+
 		const excludeModules = []
 			.concat(optionsOrFallback(options.excludeModules, options.exclude, []))
 			.map(testAgainstGivenOption);
@@ -699,6 +712,118 @@ class Stats {
 			obj.filteredModules = compilation.modules.length - obj.modules.length;
 			obj.modules.sort(sortByField(sortModules, obj.modules));
 		}
+		if (showLogging) {
+			const util = require("util");
+			obj.logging = {};
+			let acceptedTypes;
+			let collapsedGroups = false;
+			switch (showLogging) {
+				case "none":
+					acceptedTypes = new Set([]);
+					break;
+				case "error":
+					acceptedTypes = new Set([LogType.error]);
+					break;
+				case "warn":
+					acceptedTypes = new Set([LogType.error, LogType.warn]);
+					break;
+				case "info":
+					acceptedTypes = new Set([LogType.error, LogType.warn, LogType.info]);
+					break;
+				case true:
+				case "log":
+					acceptedTypes = new Set([
+						LogType.error,
+						LogType.warn,
+						LogType.info,
+						LogType.log,
+						LogType.group,
+						LogType.groupEnd,
+						LogType.groupCollapsed,
+						LogType.clear
+					]);
+					break;
+				case "verbose":
+					acceptedTypes = new Set([
+						LogType.error,
+						LogType.warn,
+						LogType.info,
+						LogType.log,
+						LogType.group,
+						LogType.groupEnd,
+						LogType.groupCollapsed,
+						LogType.profile,
+						LogType.profileEnd,
+						LogType.time,
+						LogType.status,
+						LogType.clear
+					]);
+					collapsedGroups = true;
+					break;
+			}
+			for (const [origin, logEntries] of compilation.logging) {
+				const debugMode = loggingDebug.some(fn => fn(origin));
+				let collapseCounter = 0;
+				let processedLogEntries = logEntries;
+				if (!debugMode) {
+					processedLogEntries = processedLogEntries.filter(entry => {
+						if (!acceptedTypes.has(entry.type)) return false;
+						if (!collapsedGroups) {
+							switch (entry.type) {
+								case LogType.groupCollapsed:
+									collapseCounter++;
+									return collapseCounter === 1;
+								case LogType.group:
+									if (collapseCounter > 0) collapseCounter++;
+									return collapseCounter === 0;
+								case LogType.groupEnd:
+									if (collapseCounter > 0) {
+										collapseCounter--;
+										return false;
+									}
+									return true;
+								default:
+									return collapseCounter === 0;
+							}
+						}
+						return true;
+					});
+				}
+				processedLogEntries = processedLogEntries.map(entry => {
+					let message = undefined;
+					if (entry.type === LogType.time) {
+						message = `${entry.args[0]}: ${entry.args[1] * 1000 +
+							entry.args[2] / 1000000}ms`;
+					} else if (entry.args && entry.args.length > 0) {
+						message = util.format(entry.args[0], ...entry.args.slice(1));
+					}
+					return {
+						type:
+							(debugMode || collapsedGroups) &&
+							entry.type === LogType.groupCollapsed
+								? LogType.group
+								: entry.type,
+						message,
+						trace: showLoggingTrace && entry.trace ? entry.trace : undefined
+					};
+				});
+				let name = identifierUtils
+					.makePathsRelative(context, origin, compilation.cache)
+					.replace(/\|/g, " ");
+				if (name in obj.logging) {
+					let i = 1;
+					while (`${name}#${i}` in obj.logging) {
+						i++;
+					}
+					name = `${name}#${i}`;
+				}
+				obj.logging[name] = {
+					entries: processedLogEntries,
+					filteredEntries: logEntries.length - processedLogEntries.length,
+					debug: debugMode
+				};
+			}
+		}
 		if (showChildren) {
 			obj.children = compilation.children.map((child, idx) => {
 				const childOptions = Stats.getChildOptions(options, idx);
@@ -1305,6 +1430,100 @@ class Stats {
 
 		processModulesList(obj, "");
 
+		if (obj.logging) {
+			for (const origin of Object.keys(obj.logging)) {
+				const logData = obj.logging[origin];
+				if (logData.entries.length > 0) {
+					newline();
+					if (logData.debug) {
+						colors.red("DEBUG ");
+					}
+					colors.bold("LOG from " + origin);
+					newline();
+					let indent = "";
+					for (const entry of logData.entries) {
+						let color = colors.normal;
+						let prefix = "    ";
+						switch (entry.type) {
+							case LogType.clear:
+								colors.normal(`${indent}-------`);
+								newline();
+								continue;
+							case LogType.error:
+								color = colors.red;
+								prefix = "<e> ";
+								break;
+							case LogType.warn:
+								color = colors.yellow;
+								prefix = "<w> ";
+								break;
+							case LogType.info:
+								color = colors.green;
+								prefix = "<i> ";
+								break;
+							case LogType.log:
+								color = colors.bold;
+								break;
+							case LogType.trace:
+							case LogType.debug:
+								color = colors.normal;
+								break;
+							case LogType.status:
+								color = colors.magenta;
+								prefix = "<s> ";
+								break;
+							case LogType.profile:
+								color = colors.magenta;
+								prefix = "<p> ";
+								break;
+							case LogType.profileEnd:
+								color = colors.magenta;
+								prefix = "</p> ";
+								break;
+							case LogType.time:
+								color = colors.magenta;
+								prefix = "<t> ";
+								break;
+							case LogType.group:
+								color = colors.cyan;
+								prefix = "<-> ";
+								break;
+							case LogType.groupCollapsed:
+								color = colors.cyan;
+								prefix = "<+> ";
+								break;
+							case LogType.groupEnd:
+								if (indent.length >= 2)
+									indent = indent.slice(0, indent.length - 2);
+								continue;
+						}
+						if (entry.message) {
+							for (const line of entry.message.split("\n")) {
+								colors.normal(`${indent}${prefix}`);
+								color(line);
+								newline();
+							}
+						}
+						if (entry.trace) {
+							for (const line of entry.trace) {
+								colors.normal(`${indent}| ${line}`);
+								newline();
+							}
+						}
+						switch (entry.type) {
+							case LogType.group:
+								indent += "  ";
+								break;
+						}
+					}
+					if (logData.filteredEntries) {
+						colors.normal(`+ ${logData.filteredEntries} hidden lines`);
+						newline();
+					}
+				}
+			}
+		}
+
 		if (obj._showWarnings && obj.warnings) {
 			for (const warning of obj.warnings) {
 				newline();
@@ -1375,6 +1594,7 @@ class Stats {
 					optimizationBailout: true,
 					errorDetails: true,
 					publicPath: true,
+					logging: "verbose",
 					exclude: false,
 					maxModules: Infinity
 				};
@@ -1391,6 +1611,7 @@ class Stats {
 					optimizationBailout: true,
 					errorDetails: true,
 					publicPath: true,
+					logging: true,
 					exclude: false,
 					maxModules: Infinity
 				};
@@ -1400,19 +1621,22 @@ class Stats {
 					modules: true,
 					maxModules: 0,
 					errors: true,
-					warnings: true
+					warnings: true,
+					logging: "warn"
 				};
 			case "errors-only":
 				return {
 					all: false,
 					errors: true,
-					moduleTrace: true
+					moduleTrace: true,
+					logging: "error"
 				};
 			case "errors-warnings":
 				return {
 					all: false,
 					errors: true,
-					warnings: true
+					warnings: true,
+					logging: "warn"
 				};
 			default:
 				return {};

package/lib/SystemMainTemplatePlugin.js

@@ -34,7 +34,11 @@ class SystemMainTemplatePlugin {
 			const externals = chunk.getModules().filter(m => m.external);
 
 			// The name this bundle should be registered as with System
-			const name = this.name ? `${JSON.stringify(this.name)}, ` : "";
+			const name = this.name
+				? `${JSON.stringify(
+						mainTemplate.getAssetPath(this.name, { hash, chunk })
+				  )}, `
+				: "";
 
 			// The array of dependencies that are external to webpack and will be provided by System
 			const systemDependencies = JSON.stringify(