webpack 4.35.2 → 4.37.0

package/declarations/WebpackOptions.d.ts

@@ -75,6 +75,16 @@ export type ExternalItem =
  * via the `definition` "ArrayOfStringValues".
  */
 export type ArrayOfStringValues = string[];
+/**
+ * This interface was referenced by `WebpackOptions`'s JSON-Schema
+ * via the `definition` "FilterTypes".
+ */
+export type FilterTypes = FilterItemTypes | FilterItemTypes[];
+/**
+ * This interface was referenced by `WebpackOptions`'s JSON-Schema
+ * via the `definition` "FilterItemTypes".
+ */
+export type FilterItemTypes = RegExp | string | ((value: string) => boolean);
 /**
  * One or multiple rule conditions
  *
@@ -235,16 +245,6 @@ export type WebpackPluginFunction = (
  * via the `definition` "RuleSetRules".
  */
 export type RuleSetRules = RuleSetRule[];
-/**
- * This interface was referenced by `WebpackOptions`'s JSON-Schema
- * via the `definition` "FilterTypes".
- */
-export type FilterTypes = FilterItemTypes | FilterItemTypes[];
-/**
- * This interface was referenced by `WebpackOptions`'s JSON-Schema
- * via the `definition` "FilterItemTypes".
- */
-export type FilterItemTypes = RegExp | string | Function;
 
 export interface WebpackOptions {
 	/**
@@ -293,6 +293,19 @@ export interface WebpackOptions {
 	 * Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.
 	 */
 	externals?: Externals;
+	/**
+	 * Options for infrastructure level logging
+	 */
+	infrastructureLogging?: {
+		/**
+		 * Enable debug logging for specific loggers
+		 */
+		debug?: FilterTypes | boolean;
+		/**
+		 * Log level
+		 */
+		level?: "none" | "error" | "warn" | "info" | "log" | "verbose";
+	};
 	/**
 	 * Custom values available in the loader context.
 	 */
@@ -1094,7 +1107,7 @@ export interface OutputOptions {
 	/**
 	 * Algorithm used for generation the hash (see node.js crypto package)
 	 */
-	hashFunction?: string | (new () => import("../lib/util/createHash").Hash);
+	hashFunction?: string | import("../lib/util/createHash").HashConstructor;
 	/**
 	 * Any string which is added to the hash to salt it
 	 */
@@ -1343,6 +1356,18 @@ export interface StatsOptions {
 	 * add the hash of the compilation
 	 */
 	hash?: boolean;
+	/**
+	 * add logging output
+	 */
+	logging?: boolean | ("none" | "error" | "warn" | "info" | "log" | "verbose");
+	/**
+	 * Include debug logging of specified loggers (i. e. for plugins or loaders). Filters can be Strings, RegExps or Functions
+	 */
+	loggingDebug?: FilterTypes | boolean;
+	/**
+	 * add stack traces to logging output
+	 */
+	loggingTrace?: boolean;
 	/**
 	 * Set the maximum number of modules to be shown
 	 */

package/lib/AbstractMethodError.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
+
+/**
+ * @param {string=} method method name
+ * @returns {string} message
+ */
+function createMessage(method) {
+	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
+}
+
+/**
+ * @constructor
+ */
+function Message() {
+	this.stack = undefined;
+	Error.captureStackTrace(this);
+	/** @type {RegExpMatchArray} */
+	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+
+	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
+}
+
+/**
+ * Error for abstract method
+ * @example
+ * class FooClass {
+ *     abstractMethod() {
+ *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overriden.
+ *     }
+ * }
+ *
+ */
+class AbstractMethodError extends WebpackError {
+	constructor() {
+		super(new Message().message);
+		this.name = "AbstractMethodError";
+	}
+}
+
+module.exports = AbstractMethodError;

package/lib/Compilation.js

@@ -36,6 +36,8 @@ const SortableSet = require("./util/SortableSet");
 const GraphHelpers = require("./GraphHelpers");
 const ModuleDependency = require("./dependencies/ModuleDependency");
 const compareLocations = require("./compareLocations");
+const { Logger, LogType } = require("./logging/Logger");
+const ErrorHelpers = require("./ErrorHelpers");
 
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Compiler")} Compiler */
@@ -95,6 +97,14 @@ const compareLocations = require("./compareLocations");
  * @property {DependenciesBlockVariable[]} variables
  */
 
+/**
+ * @typedef {Object} LogEntry
+ * @property {string} type
+ * @property {any[]} args
+ * @property {number} time
+ * @property {string[]=} trace
+ */
+
 /**
  * @param {Chunk} a first chunk to sort by id
  * @param {Chunk} b second chunk to sort by id
@@ -384,6 +394,9 @@ class Compilation extends Tapable {
 				"compilerIndex"
 			]),
 
+			/** @type {SyncBailHook<string, LogEntry>} */
+			log: new SyncBailHook(["origin", "logEntry"]),
+
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
 			/** @type {SyncHook<object, Module>} */
@@ -469,6 +482,8 @@ class Compilation extends Tapable {
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
+		/** @type {Map<string, LogEntry[]>} */
+		this.logging = new Map();
 		/** @type {Map<DepConstructor, ModuleFactory>} */
 		this.dependencyFactories = new Map();
 		/** @type {Map<DepConstructor, DependencyTemplate>} */
@@ -499,6 +514,69 @@ class Compilation extends Tapable {
 		return new Stats(this);
 	}
 
+	/**
+	 * @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
+	 */
+	getLogger(name) {
+		if (!name) {
+			throw new TypeError("Compilation.getLogger(name) called without a name");
+		}
+		/** @type {LogEntry[] | undefined} */
+		let logEntries;
+		return new Logger((type, args) => {
+			if (typeof name === "function") {
+				name = name();
+				if (!name) {
+					throw new TypeError(
+						"Compilation.getLogger(name) called with a function not returning a name"
+					);
+				}
+			}
+			let trace;
+			switch (type) {
+				case LogType.warn:
+				case LogType.error:
+				case LogType.trace:
+					trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+						.split("\n")
+						.slice(3);
+					break;
+			}
+			/** @type {LogEntry} */
+			const logEntry = {
+				time: Date.now(),
+				type,
+				args,
+				trace
+			};
+			if (this.hooks.log.call(name, logEntry) === undefined) {
+				if (logEntry.type === LogType.profileEnd) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.profileEnd === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+					}
+				}
+				if (logEntries === undefined) {
+					logEntries = this.logging.get(name);
+					if (logEntries === undefined) {
+						logEntries = [];
+						this.logging.set(name, logEntries);
+					}
+				}
+				logEntries.push(logEntry);
+				if (logEntry.type === LogType.profile) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.profile === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.profile(`[${name}] ${logEntry.args[0]}`);
+					}
+				}
+			}
+		});
+	}
+
 	/**
 	 * @typedef {Object} AddModuleResult
 	 * @property {Module} module the added or existing module
@@ -2294,7 +2372,7 @@ class Compilation extends Tapable {
 			const module = modules[i];
 			const moduleHash = createHash(hashFunction);
 			module.updateHash(moduleHash);
-			module.hash = moduleHash.digest(hashDigest);
+			module.hash = /** @type {string} */ (moduleHash.digest(hashDigest));
 			module.renderedHash = module.hash.substr(0, hashDigestLength);
 		}
 		// clone needed as sort below is inplace mutation
@@ -2329,7 +2407,7 @@ class Compilation extends Tapable {
 					this.dependencyTemplates
 				);
 				this.hooks.chunkHash.call(chunk, chunkHash);
-				chunk.hash = chunkHash.digest(hashDigest);
+				chunk.hash = /** @type {string} */ (chunkHash.digest(hashDigest));
 				hash.update(chunk.hash);
 				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
 				this.hooks.contentHash.call(chunk);
@@ -2337,7 +2415,7 @@ class Compilation extends Tapable {
 				this.errors.push(new ChunkRenderError(chunk, "", err));
 			}
 		}
-		this.fullHash = hash.digest(hashDigest);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
 		this.hash = this.fullHash.substr(0, hashDigestLength);
 	}
 
@@ -2353,7 +2431,7 @@ class Compilation extends Tapable {
 		const hash = createHash(hashFunction);
 		hash.update(this.fullHash);
 		hash.update(update);
-		this.fullHash = hash.digest(hashDigest);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
 		this.hash = this.fullHash.substr(0, hashDigestLength);
 	}
 

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 */
@@ -84,6 +85,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} */
@@ -137,6 +141,8 @@ class Compiler extends Tapable {
 		/** @type {ResolverFactory} */
 		this.resolverFactory = new ResolverFactory();
 
+		this.infrastructureLogger = undefined;
+
 		// TODO remove in webpack 5
 		this.resolvers = {
 			normal: {
@@ -196,6 +202,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());
 

package/lib/HashedModuleIdsPlugin.js

@@ -45,7 +45,9 @@ class HashedModuleIdsPlugin {
 							});
 							const hash = createHash(options.hashFunction);
 							hash.update(id);
-							const hashId = hash.digest(options.hashDigest);
+							const hashId = /** @type {string} */ (hash.digest(
+								options.hashDigest
+							));
 							let len = options.hashDigestLength;
 							while (usedIds.has(hashId.substr(0, len))) len++;
 							module.id = hashId.substr(0, len);

package/lib/JavascriptModulesPlugin.js

@@ -148,9 +148,8 @@ class JavascriptModulesPlugin {
 							hash.update(m.hash);
 						}
 					}
-					chunk.contentHash.javascript = hash
-						.digest(hashDigest)
-						.substr(0, hashDigestLength);
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
 				});
 			}
 		);

package/lib/JsonGenerator.js

@@ -28,6 +28,7 @@ class JsonGenerator {
 				})
 			);
 		}
+		let finalJson;
 		if (
 			Array.isArray(module.buildMeta.providedExports) &&
 			!module.isUsed("default")
@@ -41,12 +42,14 @@ class JsonGenerator {
 					reducedJson[used] = data[exportName];
 				}
 			}
-			source.add(
-				`${module.moduleArgument}.exports = ${stringifySafe(reducedJson)};`
-			);
+			finalJson = reducedJson;
 		} else {
-			source.add(`${module.moduleArgument}.exports = ${stringifySafe(data)};`);
+			finalJson = data;
 		}
+		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
+		const jsonSource = JSON.stringify(stringifySafe(finalJson));
+		const jsonExpr = `JSON.parse(${jsonSource})`;
+		source.add(`${module.moduleArgument}.exports = ${jsonExpr};`);
 		return source;
 	}
 }

package/lib/ModuleFilenameHelpers.js

@@ -44,7 +44,8 @@ const getBefore = (str, token) => {
 const getHash = str => {
 	const hash = createHash("md4");
 	hash.update(str);
-	return hash.digest("hex").substr(0, 4);
+	const digest = /** @type {string} */ (hash.digest("hex"));
+	return digest.substr(0, 4);
 };
 
 const asRegExp = test => {

package/lib/NamedModulesPlugin.js

@@ -10,7 +10,8 @@ const RequestShortener = require("./RequestShortener");
 const getHash = str => {
 	const hash = createHash("md4");
 	hash.update(str);
-	return hash.digest("hex").substr(0, 4);
+	const digest = /** @type {string} */ (hash.digest("hex"));
+	return digest.substr(0, 4);
 };
 
 class NamedModulesPlugin {

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'.
@@ -405,7 +416,7 @@ class NormalModule extends Module {
 		}
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
-		this._buildHash = hash.digest("hex");
+		this._buildHash = /** @type {string} */ (hash.digest("hex"));
 	}
 
 	build(options, compilation, resolver, fs, callback) {

package/lib/NormalModuleFactory.js

@@ -17,7 +17,7 @@ const {
 const NormalModule = require("./NormalModule");
 const RawModule = require("./RawModule");
 const RuleSet = require("./RuleSet");
-const cachedMerge = require("./util/cachedMerge");
+const { cachedCleverMerge } = require("./util/cleverMerge");
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
@@ -304,7 +304,7 @@ class NormalModuleFactory extends Tapable {
 							typeof settings[r.type] === "object" &&
 							settings[r.type] !== null
 						) {
-							settings[r.type] = cachedMerge(settings[r.type], r.value);
+							settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
 						} else {
 							settings[r.type] = r.value;
 						}

package/lib/OptionsDefaulter.js

@@ -6,8 +6,8 @@
 
 /**
  * Gets the value at path of object
- * @param {object} obj - object to query
- * @param {string} path - query path
+ * @param {object} obj object to query
+ * @param {string} path query path
  * @returns {any} - if {@param path} requests element from array, then `undefined` will be returned
  */
 const getProperty = (obj, path) => {
@@ -21,9 +21,9 @@ const getProperty = (obj, path) => {
 
 /**
  * Sets the value at path of object. Stops execution, if {@param path} requests element from array to be set
- * @param {object} obj - object to query
- * @param {string} path - query path
- * @param {any} value - value to be set
+ * @param {object} obj object to query
+ * @param {string} path query path
+ * @param {any} value value to be set
  * @returns {void}
  */
 const setProperty = (obj, path, value) => {
@@ -65,7 +65,7 @@ class OptionsDefaulter {
 
 	/**
 	 * Enhancing {@param options} with default values
-	 * @param {object} options - provided options
+	 * @param {object} options provided options
 	 * @returns {object} - enhanced options
 	 * @throws {Error} - will throw error, if configuration value is other then `undefined` or {@link ConfigType}
 	 */
@@ -122,9 +122,9 @@ class OptionsDefaulter {
 
 	/**
 	 * Builds up default values
-	 * @param {string} name - option path
-	 * @param {ConfigType | any} config - if {@param def} is provided, then only {@link ConfigType} is allowed
-	 * @param {MakeConfigHandler | CallConfigHandler | AppendConfigValues} [def] - defaults
+	 * @param {string} name option path
+	 * @param {ConfigType | any} config if {@param def} is provided, then only {@link ConfigType} is allowed
+	 * @param {MakeConfigHandler | CallConfigHandler | AppendConfigValues} [def] defaults
 	 * @returns {void}
 	 */
 	set(name, config, def) {

package/lib/Parser.js

@@ -7,14 +7,13 @@
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 
 const acorn = require("acorn");
-const acornDynamicImport = require("acorn-dynamic-import").default;
 const { Tapable, SyncBailHook, HookMap } = require("tapable");
 const util = require("util");
 const vm = require("vm");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 const StackedSetMap = require("./util/StackedSetMap");
 
-const acornParser = acorn.Parser.extend(acornDynamicImport);
+const acornParser = acorn.Parser;
 
 const joinRanges = (startRange, endRange) => {
 	if (!endRange) return startRange;
@@ -25,7 +24,7 @@ const joinRanges = (startRange, endRange) => {
 const defaultParserOptions = {
 	ranges: true,
 	locations: true,
-	ecmaVersion: 2019,
+	ecmaVersion: 11,
 	sourceType: "module",
 	onComment: null
 };

package/lib/ResolverFactory.js

@@ -6,9 +6,12 @@
 
 const { Tapable, HookMap, SyncHook, SyncWaterfallHook } = require("tapable");
 const Factory = require("enhanced-resolve").ResolverFactory;
+const { cachedCleverMerge } = require("./util/cleverMerge");
 
 /** @typedef {import("enhanced-resolve").Resolver} Resolver */
 
+const EMTPY_RESOLVE_OPTIONS = {};
+
 module.exports = class ResolverFactory extends Tapable {
 	constructor() {
 		super();
@@ -22,30 +25,24 @@ 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;
 			}
 		});
-		this.cache1 = new WeakMap();
 		this.cache2 = new Map();
 	}
 
 	get(type, resolveOptions) {
-		const cachedResolver = this.cache1.get(resolveOptions);
-		if (cachedResolver) return cachedResolver();
+		resolveOptions = resolveOptions || EMTPY_RESOLVE_OPTIONS;
 		const ident = `${type}|${JSON.stringify(resolveOptions)}`;
 		const resolver = this.cache2.get(ident);
 		if (resolver) return resolver;
@@ -66,7 +63,7 @@ module.exports = class ResolverFactory extends Tapable {
 		resolver.withOptions = options => {
 			const cacheEntry = childCache.get(options);
 			if (cacheEntry !== undefined) return cacheEntry;
-			const mergedOptions = Object.assign({}, originalResolveOptions, options);
+			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
 			const resolver = this.get(type, mergedOptions);
 			childCache.set(options, resolver);
 			return resolver;