webpack 4.35.2 → 4.37.0

package/lib/SourceMapDevToolPlugin.js

@@ -14,25 +14,66 @@ const validateOptions = require("schema-utils");
 const schema = require("../schemas/plugins/SourceMapDevToolPlugin.json");
 
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("source-map").RawSourceMap} SourceMap */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compilation")} SourceMapDefinition */
 
+/**
+ * @typedef {object} SourceMapTask
+ * @property {Source} asset
+ * @property {Array<string | Module>} [modules]
+ * @property {string} source
+ * @property {string} file
+ * @property {SourceMap} sourceMap
+ * @property {Chunk} chunk
+ */
+
+/**
+ * @param {string} name file path
+ * @returns {string} file name
+ */
 const basename = name => {
 	if (!name.includes("/")) return name;
 	return name.substr(name.lastIndexOf("/") + 1);
 };
 
+/**
+ * @type {WeakMap<Source, {file: string, assets: {[k: string]: ConcatSource | RawSource}}>}
+ */
 const assetsCache = new WeakMap();
 
+/**
+ * Creating {@link SourceMapTask} for given file
+ * @param {string} file current compiled file
+ * @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;
 	}
 	let source, sourceMap;
+	/**
+	 * Check if asset can build source map
+	 */
 	if (asset.sourceAndMap) {
 		const sourceAndMap = asset.sourceAndMap(options);
 		sourceMap = sourceAndMap.map;
@@ -55,7 +96,8 @@ const getTaskForFile = (file, chunk, options, compilation) => {
 
 class SourceMapDevToolPlugin {
 	/**
-	 * @param {SourceMapDevToolPluginOptions=} options options object
+	 * @param {SourceMapDevToolPluginOptions} [options] options object
+	 * @throws {Error} throws error, if got more than 1 arguments
 	 */
 	constructor(options) {
 		if (arguments.length > 1) {
@@ -68,21 +110,31 @@ class SourceMapDevToolPlugin {
 
 		validateOptions(schema, options, "SourceMap DevTool Plugin");
 
+		/** @type {string | false} */
 		this.sourceMapFilename = options.filename;
 		/** @type {string | false} */
 		this.sourceMappingURLComment =
 			options.append === false
 				? false
 				: options.append || "\n//# sourceMappingURL=[url]";
+		/** @type {string | Function} */
 		this.moduleFilenameTemplate =
 			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
+		/** @type {string | Function} */
 		this.fallbackModuleFilenameTemplate =
 			options.fallbackModuleFilenameTemplate ||
 			"webpack://[namespace]/[resourcePath]?[hash]";
+		/** @type {string} */
 		this.namespace = options.namespace || "";
+		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
 	}
 
+	/**
+	 * Apply compiler
+	 * @param {Compiler} compiler compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const sourceMapFilename = this.sourceMapFilename;
 		const sourceMappingURLComment = this.sourceMappingURLComment;
@@ -102,12 +154,21 @@ class SourceMapDevToolPlugin {
 			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
 			compilation.hooks.afterOptimizeChunkAssets.tap(
-				{
-					name: "SourceMapDevToolPlugin",
-					context: true
-				},
+				/** @type {TODO} */
+				({ name: "SourceMapDevToolPlugin", context: true }),
+				/**
+				 * @param {object} context hook context
+				 * @param {Array<Chunk>} chunks resulted chunks
+				 * @throws {Error} throws error, if `sourceMapFilename === false && sourceMappingURLComment === false`
+				 * @returns {void}
+				 */
 				(context, chunks) => {
+					/** @type {Map<string | Module, string>} */
 					const moduleToSourceNameMapping = new Map();
+					/**
+					 * @type {Function}
+					 * @returns {void}
+					 */
 					const reportProgress =
 						context && context.reportProgress
 							? context.reportProgress
@@ -133,6 +194,7 @@ class SourceMapDevToolPlugin {
 							file,
 							"generate SourceMap"
 						);
+						/** @type {SourceMapTask | undefined} */
 						const task = getTaskForFile(file, chunk, options, compilation);
 
 						if (task) {
@@ -165,10 +227,15 @@ class SourceMapDevToolPlugin {
 					});
 
 					reportProgress(0.5, "resolve sources");
+					/** @type {Set<string>} */
 					const usedNamesSet = new Set(moduleToSourceNameMapping.values());
+					/** @type {Set<string>} */
 					const conflictDetectionSet = new Set();
 
-					// all modules in defined order (longest identifier first)
+					/**
+					 * all modules in defined order (longest identifier first)
+					 * @type {Array<string | Module>}
+					 */
 					const allModules = Array.from(moduleToSourceNameMapping.keys()).sort(
 						(a, b) => {
 							const ai = typeof a === "string" ? a : a.identifier();
@@ -254,7 +321,7 @@ class SourceMapDevToolPlugin {
 								query = filename.substr(idx);
 								filename = filename.substr(0, idx);
 							}
-							let sourceMapFile = compilation.getPath(sourceMapFilename, {
+							const pathParams = {
 								chunk,
 								filename: options.fileContext
 									? path.relative(options.fileContext, filename)
@@ -264,21 +331,31 @@ class SourceMapDevToolPlugin {
 								contentHash: createHash("md4")
 									.update(sourceMapString)
 									.digest("hex")
-							});
+							};
+							let sourceMapFile = compilation.getPath(
+								sourceMapFilename,
+								pathParams
+							);
 							const sourceMapUrl = options.publicPath
 								? options.publicPath + sourceMapFile.replace(/\\/g, "/")
 								: path
 										.relative(path.dirname(file), sourceMapFile)
 										.replace(/\\/g, "/");
+							/**
+							 * Add source map url to compilation asset, if {@link currentSourceMappingURLComment} presented
+							 */
 							if (currentSourceMappingURLComment !== false) {
 								assets[file] = compilation.assets[file] = new ConcatSource(
 									new RawSource(source),
-									currentSourceMappingURLComment.replace(
-										/\[url\]/g,
-										sourceMapUrl
+									compilation.getPath(
+										currentSourceMappingURLComment,
+										Object.assign({ url: sourceMapUrl }, pathParams)
 									)
 								);
 							}
+							/**
+							 * Add source map file to compilation assets and chunk files
+							 */
 							assets[sourceMapFile] = compilation.assets[
 								sourceMapFile
 							] = new RawSource(sourceMapString);
@@ -289,6 +366,9 @@ class SourceMapDevToolPlugin {
 									"SourceMapDevToolPlugin: append can't be false when no filename is provided"
 								);
 							}
+							/**
+							 * Add source map as data url to asset
+							 */
 							assets[file] = compilation.assets[file] = new ConcatSource(
 								new RawSource(source),
 								currentSourceMappingURLComment

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

@@ -363,6 +363,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);
 	}
 }
 

package/lib/debug/ProfilingPlugin.js

@@ -78,8 +78,8 @@ class Profiler {
 }
 
 /**
+ * an object that wraps Tracer and Profiler with a counter
  * @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