webpack 4.35.3 → 4.38.0

package/lib/logging/Logger.js

@@ -0,0 +1,126 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+
+"use strict";
+
+/**
+ * @enum {string}
+ */
+const LogType = Object.freeze({
+	error: "error", // message, c style arguments
+	warn: "warn", // message, c style arguments
+	info: "info", // message, c style arguments
+	log: "log", // message, c style arguments
+	debug: "debug", // message, c style arguments
+
+	trace: "trace", // no arguments
+
+	group: "group", // [label]
+	groupCollapsed: "groupCollapsed", // [label]
+	groupEnd: "groupEnd", // [label]
+
+	profile: "profile", // [profileName]
+	profileEnd: "profileEnd", // [profileName]
+
+	time: "time", // name, time as [seconds, nanoseconds]
+
+	clear: "clear" // no arguments
+});
+
+exports.LogType = LogType;
+
+/** @typedef {LogType} LogTypeEnum */
+
+const LOG_SYMBOL = Symbol("webpack logger raw log method");
+const TIMERS_SYMBOL = Symbol("webpack logger times");
+
+class WebpackLogger {
+	/**
+	 * @param {function(LogType, any[]=): void} log log function
+	 */
+	constructor(log) {
+		this[LOG_SYMBOL] = log;
+	}
+
+	error(...args) {
+		this[LOG_SYMBOL](LogType.error, args);
+	}
+
+	warn(...args) {
+		this[LOG_SYMBOL](LogType.warn, args);
+	}
+
+	info(...args) {
+		this[LOG_SYMBOL](LogType.info, args);
+	}
+
+	log(...args) {
+		this[LOG_SYMBOL](LogType.log, args);
+	}
+
+	debug(...args) {
+		this[LOG_SYMBOL](LogType.debug, args);
+	}
+
+	assert(assertion, ...args) {
+		if (!assertion) {
+			this[LOG_SYMBOL](LogType.error, args);
+		}
+	}
+
+	trace() {
+		this[LOG_SYMBOL](LogType.trace, ["Trace"]);
+	}
+
+	clear() {
+		this[LOG_SYMBOL](LogType.clear);
+	}
+
+	group(...args) {
+		this[LOG_SYMBOL](LogType.group, args);
+	}
+
+	groupCollapsed(...args) {
+		this[LOG_SYMBOL](LogType.groupCollapsed, args);
+	}
+
+	groupEnd(...args) {
+		this[LOG_SYMBOL](LogType.groupEnd, args);
+	}
+
+	profile(label) {
+		this[LOG_SYMBOL](LogType.profile, [label]);
+	}
+
+	profileEnd(label) {
+		this[LOG_SYMBOL](LogType.profileEnd, [label]);
+	}
+
+	time(label) {
+		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+		this[TIMERS_SYMBOL].set(label, process.hrtime());
+	}
+
+	timeLog(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+		}
+		const time = process.hrtime(prev);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
+
+	timeEnd(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+		}
+		const time = process.hrtime(prev);
+		this[TIMERS_SYMBOL].delete(label);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
+}
+
+exports.Logger = WebpackLogger;

package/lib/logging/createConsoleLogger.js

@@ -0,0 +1,188 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { LogType } = require("./Logger");
+
+/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
+/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
+/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
+
+/** @typedef {function(string): boolean} FilterFunction */
+
+/**
+ * @typedef {Object} LoggerOptions
+ * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} options.level loglevel
+ * @property {FilterTypes|boolean} options.debug filter for debug logging
+ */
+
+/**
+ * @param {FilterItemTypes} item an input item
+ * @returns {FilterFunction} filter funtion
+ */
+const filterToFunction = item => {
+	if (typeof item === "string") {
+		const regExp = new RegExp(
+			`[\\\\/]${item.replace(
+				// eslint-disable-next-line no-useless-escape
+				/[-[\]{}()*+?.\\^$|]/g,
+				"\\$&"
+			)}([\\\\/]|$|!|\\?)`
+		);
+		return ident => regExp.test(ident);
+	}
+	if (item && typeof item === "object" && typeof item.test === "function") {
+		return ident => item.test(ident);
+	}
+	if (typeof item === "function") {
+		return item;
+	}
+	if (typeof item === "boolean") {
+		return () => item;
+	}
+};
+
+/**
+ * @enum {number} */
+const LogLevel = {
+	none: 6,
+	false: 6,
+	error: 5,
+	warn: 4,
+	info: 3,
+	log: 2,
+	true: 2,
+	verbose: 1
+};
+
+/**
+ * @param {LoggerOptions} options options object
+ * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ */
+module.exports = ({ level = "info", debug = false }) => {
+	const debugFilters =
+		typeof debug === "boolean"
+			? [() => debug]
+			: /** @type {FilterItemTypes[]} */ ([])
+					.concat(debug)
+					.map(filterToFunction);
+	/** @type {number} */
+	const loglevel = LogLevel[`${level}`] || 0;
+
+	/**
+	 * @param {string} name name of the logger
+	 * @param {LogTypeEnum} type type of the log entry
+	 * @param {any[]} args arguments of the log entry
+	 * @returns {void}
+	 */
+	const logger = (name, type, args) => {
+		const labeledArgs = (prefix = "") => {
+			if (Array.isArray(args)) {
+				if (args.length > 0 && typeof args[0] === "string") {
+					return [`${prefix}[${name}] ${args[0]}`, ...args.slice(1)];
+				} else {
+					return [`${prefix}[${name}]`, ...args];
+				}
+			} else {
+				return [];
+			}
+		};
+		const debug = debugFilters.some(f => f(name));
+		switch (type) {
+			case LogType.debug:
+				if (!debug) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.debug === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.debug(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.log:
+				if (!debug && loglevel > LogLevel.log) return;
+				console.log(...labeledArgs());
+				break;
+			case LogType.info:
+				if (!debug && loglevel > LogLevel.info) return;
+				console.info(...labeledArgs("<i> "));
+				break;
+			case LogType.warn:
+				if (!debug && loglevel > LogLevel.warn) return;
+				console.warn(...labeledArgs("<w> "));
+				break;
+			case LogType.error:
+				if (!debug && loglevel > LogLevel.error) return;
+				console.error(...labeledArgs("<e> "));
+				break;
+			case LogType.trace:
+				if (!debug) return;
+				console.trace();
+				break;
+			case LogType.group:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.group === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.group(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.groupCollapsed:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.groupCollapsed === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.groupCollapsed(...labeledArgs());
+				} else {
+					console.log(...labeledArgs("<g> "));
+				}
+				break;
+			case LogType.groupEnd:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.groupEnd === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.groupEnd();
+				} else {
+					console.log(...labeledArgs("</g> "));
+				}
+				break;
+			case LogType.time:
+				if (!debug && loglevel > LogLevel.log) return;
+				console.log(
+					`[${name}] ${args[0]}: ${args[1] * 1000 + args[2] / 1000000}ms`
+				);
+				break;
+			case 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(...labeledArgs());
+				}
+				break;
+			case 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(...labeledArgs());
+				}
+				break;
+			case LogType.clear:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.clear === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.clear();
+				}
+				break;
+			default:
+				throw new Error(`Unexpected LogType ${type}`);
+		}
+	};
+	return logger;
+};

package/lib/logging/runtime.js

@@ -0,0 +1,35 @@
+const SyncBailHook = require("tapable/lib/SyncBailHook");
+const { Logger } = require("./Logger");
+const createConsoleLogger = require("./createConsoleLogger");
+
+/** @type {createConsoleLogger.LoggerOptions} */
+let currentDefaultLoggerOptions = {
+	level: "info",
+	debug: false
+};
+let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+
+/**
+ * @param {string} name name of the logger
+ * @returns {Logger} a logger
+ */
+exports.getLogger = name => {
+	return new Logger((type, args) => {
+		if (exports.hooks.log.call(name, type, args) === undefined) {
+			currentDefaultLogger(name, type, args);
+		}
+	});
+};
+
+/**
+ * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
+ * @returns {void}
+ */
+exports.configureDefaultLogger = options => {
+	Object.assign(currentDefaultLoggerOptions, options);
+	currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
+};
+
+exports.hooks = {
+	log: new SyncBailHook(["origin", "type", "args"])
+};

package/lib/node/NodeEnvironmentPlugin.js

@@ -8,9 +8,23 @@ const NodeWatchFileSystem = require("./NodeWatchFileSystem");
 const NodeOutputFileSystem = require("./NodeOutputFileSystem");
 const NodeJsInputFileSystem = require("enhanced-resolve/lib/NodeJsInputFileSystem");
 const CachedInputFileSystem = require("enhanced-resolve/lib/CachedInputFileSystem");
+const createConsoleLogger = require("../logging/createConsoleLogger");
 
 class NodeEnvironmentPlugin {
+	constructor(options) {
+		this.options = options || {};
+	}
+
 	apply(compiler) {
+		compiler.infrastructureLogger = createConsoleLogger(
+			Object.assign(
+				{
+					level: "info",
+					debug: false
+				},
+				this.options.infrastructureLogging
+			)
+		);
 		compiler.inputFileSystem = new CachedInputFileSystem(
 			new NodeJsInputFileSystem(),
 			60000

package/lib/util/cleverMerge.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const mergeCache = new WeakMap();
+
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {object} first first object
+ * @param {object} second second object
+ * @returns {object} merged object of first and second object
+ */
+const cachedCleverMerge = (first, second) => {
+	let innerCache = mergeCache.get(first);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		mergeCache.set(first, innerCache);
+	}
+	const prevMerge = innerCache.get(second);
+	if (prevMerge !== undefined) return prevMerge;
+	const newMerge = cleverMerge(first, second);
+	innerCache.set(second, newMerge);
+	return newMerge;
+};
+
+/**
+ * Merges two objects. Objects are not deeply merged.
+ * TODO webpack 5: merge objects deeply clever.
+ * Arrays might reference the old value with "..."
+ * @param {object} first first object
+ * @param {object} second second object
+ * @returns {object} merged object of first and second object
+ */
+const cleverMerge = (first, second) => {
+	const newObject = Object.assign({}, first);
+	for (const key of Object.keys(second)) {
+		if (!(key in newObject)) {
+			newObject[key] = second[key];
+			continue;
+		}
+		const secondValue = second[key];
+		if (!Array.isArray(secondValue)) {
+			newObject[key] = secondValue;
+			continue;
+		}
+		const firstValue = newObject[key];
+		if (Array.isArray(firstValue)) {
+			const newArray = [];
+			for (const item of secondValue) {
+				if (item === "...") {
+					for (const item of firstValue) {
+						newArray.push(item);
+					}
+				} else {
+					newArray.push(item);
+				}
+			}
+			newObject[key] = newArray;
+		} else {
+			newObject[key] = secondValue;
+		}
+	}
+	return newObject;
+};
+
+exports.cachedCleverMerge = cachedCleverMerge;
+exports.cleverMerge = cleverMerge;

package/lib/util/createHash.js

@@ -4,24 +4,50 @@
 */
 "use strict";
 
-/** @typedef {{new(): Hash}} HashConstructor */
-/**
- * @typedef {Object} Hash
- * @property {function(string|Buffer, string=): Hash} update
- * @property {function(string): string} digest
- */
+const AbstractMethodError = require("../AbstractMethodError");
 
 const BULK_SIZE = 1000;
 
-/**
- * @implements {Hash}
- */
-class BulkUpdateDecorator {
+class Hash {
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		throw new AbstractMethodError();
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		throw new AbstractMethodError();
+	}
+}
+
+exports.Hash = Hash;
+/** @typedef {typeof Hash} HashConstructor */
+
+class BulkUpdateDecorator extends Hash {
+	/**
+	 * @param {Hash} hash hash
+	 */
 	constructor(hash) {
+		super();
 		this.hash = hash;
 		this.buffer = "";
 	}
 
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
 	update(data, inputEncoding) {
 		if (
 			inputEncoding !== undefined ||
@@ -43,6 +69,11 @@ class BulkUpdateDecorator {
 		return this;
 	}
 
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
 	digest(encoding) {
 		if (this.buffer.length > 0) {
 			this.hash.update(this.buffer);
@@ -54,18 +85,32 @@ class BulkUpdateDecorator {
 	}
 }
 
-/* istanbul ignore next */
-class DebugHash {
+/**
+ * istanbul ignore next
+ */
+class DebugHash extends Hash {
 	constructor() {
+		super();
 		this.string = "";
 	}
 
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
 	update(data, inputEncoding) {
 		if (typeof data !== "string") data = data.toString("utf-8");
 		this.string += data;
 		return this;
 	}
 
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
 	digest(encoding) {
 		return this.string.replace(/[^a-z0-9]+/gi, m =>
 			Buffer.from(m).toString("hex")

package/lib/util/objectToMap.js

@@ -2,7 +2,7 @@
  * convert an object into its 2D array equivalent to be turned
  * into an ES6 map
  *
- * @param {object} obj - any object type that works with Object.keys()
+ * @param {object} obj any object type that works with Object.keys()
  * @returns {Map<TODO, TODO>} an ES6 Map of KV pairs
  */
 module.exports = function objectToMap(obj) {

package/lib/wasm/WebAssemblyGenerator.js

@@ -48,7 +48,7 @@ const compose = (...fns) => {
 /**
  * Removes the start instruction
  *
- * @param {Object} state - unused state
+ * @param {Object} state unused state
  * @returns {ArrayBufferTransform} transform
  */
 const removeStartFunc = state => bin => {
@@ -62,7 +62,7 @@ const removeStartFunc = state => bin => {
 /**
  * Get imported globals
  *
- * @param {Object} ast - Module's AST
+ * @param {Object} ast Module's AST
  * @returns {Array<t.ModuleImport>} - nodes
  */
 const getImportedGlobals = ast => {
@@ -96,7 +96,7 @@ const getCountImportedFunc = ast => {
 /**
  * Get next type index
  *
- * @param {Object} ast - Module's AST
+ * @param {Object} ast Module's AST
  * @returns {t.Index} - index
  */
 const getNextTypeIndex = ast => {
@@ -116,8 +116,8 @@ const getNextTypeIndex = ast => {
  * in order to have the correct index we shift the index by number of external
  * functions.
  *
- * @param {Object} ast - Module's AST
- * @param {Number} countImportedFunc - number of imported funcs
+ * @param {Object} ast Module's AST
+ * @param {Number} countImportedFunc number of imported funcs
  * @returns {t.Index} - index
  */
 const getNextFuncIndex = (ast, countImportedFunc) => {
@@ -163,7 +163,7 @@ const createDefaultInitForGlobal = globalType => {
  *
  * Note that globals will become mutable.
  *
- * @param {Object} state - unused state
+ * @param {Object} state unused state
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImportedGlobals = state => bin => {
@@ -279,7 +279,7 @@ const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
  * The init function fills the globals given input arguments.
  *
  * @param {Object} state transformation state
- * @param {Object} state.ast - Module's ast
+ * @param {Object} state.ast Module's ast
  * @param {t.Identifier} state.initFuncId identifier of the init function
  * @param {t.Index} state.startAtFuncOffset index of the start function
  * @param {t.ModuleImport[]} state.importedGlobals list of imported globals

package/lib/webpack.js

@@ -40,7 +40,9 @@ const webpack = (options, callback) => {
 
 		compiler = new Compiler(options.context);
 		compiler.options = options;
-		new NodeEnvironmentPlugin().apply(compiler);
+		new NodeEnvironmentPlugin({
+			infrastructureLogging: options.infrastructureLogging
+		}).apply(compiler);
 		if (options.plugins && Array.isArray(options.plugins)) {
 			for (const plugin of options.plugins) {
 				if (typeof plugin === "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "4.35.3",
+  "version": "4.38.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -44,6 +44,7 @@
     "eslint": "^5.8.0",
     "eslint-config-prettier": "^4.0.0",
     "eslint-plugin-jest": "^22.2.2",
+    "eslint-plugin-jsdoc": "^15.3.2",
     "eslint-plugin-node": "^8.0.0",
     "eslint-plugin-prettier": "^3.0.0",
     "express": "~4.16.4",