webpack 4.35.3 → 4.38.0

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,117 @@ 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.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 +1429,95 @@ 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.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;
+								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 +1588,7 @@ class Stats {
 					optimizationBailout: true,
 					errorDetails: true,
 					publicPath: true,
+					logging: "verbose",
 					exclude: false,
 					maxModules: Infinity
 				};
@@ -1391,6 +1605,7 @@ class Stats {
 					optimizationBailout: true,
 					errorDetails: true,
 					publicPath: true,
+					logging: true,
 					exclude: false,
 					maxModules: Infinity
 				};
@@ -1400,19 +1615,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/Template.js

@@ -49,7 +49,7 @@ const stringifyIdSortPredicate = (a, b) => {
 class Template {
 	/**
 	 *
-	 * @param {Function} fn - a runtime function (.runtime.js) "template"
+	 * @param {Function} fn a runtime function (.runtime.js) "template"
 	 * @returns {string} the updated and normalized function string
 	 */
 	static getFunctionContent(fn) {

package/lib/TemplatedPathPlugin.js

@@ -13,7 +13,8 @@ const REGEXP_HASH = /\[hash(?::(\d+))?\]/gi,
 	REGEXP_MODULEID = /\[moduleid\]/gi,
 	REGEXP_FILE = /\[file\]/gi,
 	REGEXP_QUERY = /\[query\]/gi,
-	REGEXP_FILEBASE = /\[filebase\]/gi;
+	REGEXP_FILEBASE = /\[filebase\]/gi,
+	REGEXP_URL = /\[url\]/gi;
 
 // Using global RegExp for .test is dangerous
 // We use a normal RegExp instead of .test
@@ -111,6 +112,8 @@ const replacePathVariables = (path, data) => {
 			.replace(REGEXP_FILEBASE, getReplacer(data.basename))
 			// query is optional, it's OK if it's in a path but there's nothing to replace it with
 			.replace(REGEXP_QUERY, getReplacer(data.query, true))
+			// only available in sourceMappingURLComment
+			.replace(REGEXP_URL, getReplacer(data.url))
 	);
 };
 

package/lib/WebpackOptionsApply.js

@@ -37,6 +37,8 @@ const RequireContextPlugin = require("./dependencies/RequireContextPlugin");
 const RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin");
 const RequireIncludePlugin = require("./dependencies/RequireIncludePlugin");
 
+const { cachedCleverMerge } = require("./util/cleverMerge");
+
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("./Compiler")} Compiler */
 
@@ -512,8 +514,7 @@ class WebpackOptionsApply extends OptionsApply {
 					{
 						fileSystem: compiler.inputFileSystem
 					},
-					options.resolve,
-					resolveOptions
+					cachedCleverMerge(options.resolve, resolveOptions)
 				);
 			});
 		compiler.resolverFactory.hooks.resolveOptions
@@ -524,8 +525,7 @@ class WebpackOptionsApply extends OptionsApply {
 						fileSystem: compiler.inputFileSystem,
 						resolveToContext: true
 					},
-					options.resolve,
-					resolveOptions
+					cachedCleverMerge(options.resolve, resolveOptions)
 				);
 			});
 		compiler.resolverFactory.hooks.resolveOptions
@@ -535,8 +535,7 @@ class WebpackOptionsApply extends OptionsApply {
 					{
 						fileSystem: compiler.inputFileSystem
 					},
-					options.resolveLoader,
-					resolveOptions
+					cachedCleverMerge(options.resolveLoader, resolveOptions)
 				);
 			});
 		compiler.hooks.afterResolvers.call(compiler);

package/lib/WebpackOptionsDefaulter.js

@@ -196,7 +196,12 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 		);
 
 		this.set("optimization", "call", value => Object.assign({}, value));
-		this.set("optimization.removeAvailableModules", true);
+		// TODO webpack 5: Disable by default in a modes
+		this.set(
+			"optimization.removeAvailableModules",
+			"make",
+			options => options.mode !== "development"
+		);
 		this.set("optimization.removeEmptyChunks", true);
 		this.set("optimization.mergeDuplicateChunks", true);
 		this.set("optimization.flagIncludedChunks", "make", options =>
@@ -363,6 +368,12 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 				options.resolveLoader.plugins.length > 0
 			);
 		});
+
+		this.set("infrastructureLogging", "call", value =>
+			Object.assign({}, value)
+		);
+		this.set("infrastructureLogging.level", "info");
+		this.set("infrastructureLogging.debug", false);
 	}
 }