webpack 4.36.0 → 4.39.0

package/lib/logging/Logger.js

@@ -0,0 +1,131 @@
+/*
+ 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
+	status: "status" // message, 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);
+	}
+
+	status(...args) {
+		this[LOG_SYMBOL](LogType.status, args);
+	}
+
+	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,209 @@
+/*
+	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"} level loglevel
+ * @property {FilterTypes|boolean} debug filter for debug logging
+ * @property {Console & { status?: Function, logTime?: Function }} console the console to log to
+ */
+
+/**
+ * @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, console }) => {
+	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 = () => {
+			if (Array.isArray(args)) {
+				if (args.length > 0 && typeof args[0] === "string") {
+					return [`[${name}] ${args[0]}`, ...args.slice(1)];
+				} else {
+					return [`[${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());
+				break;
+			case LogType.warn:
+				if (!debug && loglevel > LogLevel.warn) return;
+				console.warn(...labeledArgs());
+				break;
+			case LogType.error:
+				if (!debug && loglevel > LogLevel.error) return;
+				console.error(...labeledArgs());
+				break;
+			case LogType.trace:
+				if (!debug) return;
+				console.trace();
+				break;
+			case LogType.groupCollapsed:
+				if (!debug && loglevel > LogLevel.log) return;
+				if (!debug && loglevel > LogLevel.verbose) {
+					// 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());
+					}
+					break;
+				}
+			// falls through
+			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.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();
+				}
+				break;
+			case LogType.time: {
+				if (!debug && loglevel > LogLevel.log) return;
+				const ms = args[1] * 1000 + args[2] / 1000000;
+				const msg = `[${name}] ${args[0]}: ${ms}ms`;
+				if (typeof console.logTime === "function") {
+					console.logTime(msg);
+				} else {
+					console.log(msg);
+				}
+				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;
+			case LogType.status:
+				if (!debug && loglevel > LogLevel.info) return;
+				if (typeof console.status === "function") {
+					if (args.length === 0) {
+						console.status();
+					} else {
+						console.status(...labeledArgs());
+					}
+				} else {
+					if (args.length !== 0) {
+						console.info(...labeledArgs());
+					}
+				}
+				break;
+			default:
+				throw new Error(`Unexpected LogType ${type}`);
+		}
+	};
+	return logger;
+};

package/lib/logging/runtime.js

@@ -0,0 +1,36 @@
+const SyncBailHook = require("tapable/lib/SyncBailHook");
+const { Logger } = require("./Logger");
+const createConsoleLogger = require("./createConsoleLogger");
+
+/** @type {createConsoleLogger.LoggerOptions} */
+let currentDefaultLoggerOptions = {
+	level: "info",
+	debug: false,
+	console
+};
+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/logging/truncateArgs.js

@@ -0,0 +1,74 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+ */
+
+"use strict";
+
+/**
+ * @param {any[]} args items to be truncated
+ * @param {number} maxLength maximum length of args including spaces between
+ * @returns {string[]} truncated args
+ */
+const truncateArgs = (args, maxLength) => {
+	const lengths = args.map(a => `${a}`.length);
+	const availableLength = maxLength - lengths.length + 1;
+
+	if (availableLength > 0 && args.length === 1) {
+		if (availableLength > 3) {
+			return ["..." + args[0].slice(-availableLength + 3)];
+		} else {
+			return [args[0].slice(-availableLength)];
+		}
+	}
+
+	// Check if there is space for at least 4 chars per arg
+	if (availableLength < lengths.reduce((s, i) => s + Math.min(i, 6), 0)) {
+		// remove args
+		if (args.length > 1)
+			return truncateArgs(args.slice(0, args.length - 1), maxLength);
+		return [];
+	}
+
+	let currentLength = lengths.reduce((a, b) => a + b, 0);
+
+	// Check if all fits into maxLength
+	if (currentLength <= availableLength) return args;
+
+	// Try to remove chars from the longest items until it fits
+	while (currentLength > availableLength) {
+		const maxLength = Math.max(...lengths);
+		const shorterItems = lengths.filter(l => l !== maxLength);
+		const nextToMaxLength =
+			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
+		const maxReduce = maxLength - nextToMaxLength;
+		let maxItems = lengths.length - shorterItems.length;
+		let overrun = currentLength - availableLength;
+		for (let i = 0; i < lengths.length; i++) {
+			if (lengths[i] === maxLength) {
+				const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
+				lengths[i] -= reduce;
+				currentLength -= reduce;
+				overrun -= reduce;
+				maxItems--;
+			}
+		}
+	}
+
+	// Return args reduced to length in lengths
+	return args.map((a, i) => {
+		const str = `${a}`;
+		const length = lengths[i];
+		if (str.length === length) {
+			return str;
+		} else if (length > 5) {
+			return "..." + str.slice(-length + 3);
+		} else if (length > 0) {
+			return str.slice(-length);
+		} else {
+			return "";
+		}
+	});
+};
+
+module.exports = truncateArgs;

package/lib/node/NodeEnvironmentPlugin.js

@@ -8,9 +8,25 @@ 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");
+const nodeConsole = require("./nodeConsole");
 
 class NodeEnvironmentPlugin {
+	constructor(options) {
+		this.options = options || {};
+	}
+
 	apply(compiler) {
+		compiler.infrastructureLogger = createConsoleLogger(
+			Object.assign(
+				{
+					level: "info",
+					debug: false,
+					console: nodeConsole
+				},
+				this.options.infrastructureLogging
+			)
+		);
 		compiler.inputFileSystem = new CachedInputFileSystem(
 			new NodeJsInputFileSystem(),
 			60000

package/lib/node/nodeConsole.js

@@ -0,0 +1,133 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const truncateArgs = require("../logging/truncateArgs");
+const util = require("util");
+
+const tty = process.stderr.isTTY && process.env.TERM !== "dumb";
+
+let currentStatusMessage = undefined;
+let hasStatusMessage = false;
+let currentIndent = "";
+let currentCollapsed = 0;
+
+const indent = (str, prefix, colorPrefix, colorSuffix) => {
+	if (str === "") return str;
+	prefix = currentIndent + prefix;
+	if (tty) {
+		return (
+			prefix +
+			colorPrefix +
+			str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+			colorSuffix
+		);
+	} else {
+		return prefix + str.replace(/\n/g, "\n" + prefix);
+	}
+};
+
+const clearStatusMessage = () => {
+	if (hasStatusMessage) {
+		process.stderr.write("\x1b[2K\r");
+		hasStatusMessage = false;
+	}
+};
+
+const writeStatusMessage = () => {
+	if (!currentStatusMessage) return;
+	const l = process.stderr.columns;
+	const args = l ? truncateArgs(currentStatusMessage, l) : currentStatusMessage;
+	const str = args.join(" ");
+	const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
+	process.stderr.write(`\x1b[2K\r${coloredStr}`);
+	hasStatusMessage = true;
+};
+
+const writeColored = (prefix, colorPrefix, colorSuffix) => {
+	return (...args) => {
+		if (currentCollapsed > 0) return;
+		clearStatusMessage();
+		// @ts-ignore
+		const str = indent(util.format(...args), prefix, colorPrefix, colorSuffix);
+		process.stderr.write(str + "\n");
+		writeStatusMessage();
+	};
+};
+
+const writeGroupMessage = writeColored(
+	"<-> ",
+	"\u001b[1m\u001b[36m",
+	"\u001b[39m\u001b[22m"
+);
+
+const writeGroupCollapsedMessage = writeColored(
+	"<+> ",
+	"\u001b[1m\u001b[36m",
+	"\u001b[39m\u001b[22m"
+);
+
+module.exports = {
+	log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+	debug: writeColored("    ", "", ""),
+	trace: writeColored("    ", "", ""),
+	info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
+	warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
+	error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+	logTime: writeColored("<t> ", "\u001b[1m\u001b[35m", "\u001b[39m\u001b[22m"),
+	group: (...args) => {
+		writeGroupMessage(...args);
+		if (currentCollapsed > 0) {
+			currentCollapsed++;
+		} else {
+			currentIndent += "  ";
+		}
+	},
+	groupCollapsed: (...args) => {
+		writeGroupCollapsedMessage(...args);
+		currentCollapsed++;
+	},
+	groupEnd: () => {
+		if (currentCollapsed > 0) currentCollapsed--;
+		else if (currentIndent.length >= 2)
+			currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+	},
+	// eslint-disable-next-line node/no-unsupported-features/node-builtins
+	profile: console.profile && (name => console.profile(name)),
+	// eslint-disable-next-line node/no-unsupported-features/node-builtins
+	profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+	clear:
+		tty &&
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		console.clear &&
+		(() => {
+			clearStatusMessage();
+			// eslint-disable-next-line node/no-unsupported-features/node-builtins
+			console.clear();
+			writeStatusMessage();
+		}),
+	status: tty
+		? (name, ...args) => {
+				args = args.filter(Boolean);
+				if (name === undefined && args.length === 0) {
+					clearStatusMessage();
+					currentStatusMessage = undefined;
+				} else if (
+					typeof name === "string" &&
+					name.startsWith("[webpack.Progress] ")
+				) {
+					currentStatusMessage = [name.slice(19), ...args];
+					writeStatusMessage();
+				} else if (name === "[webpack.Progress]") {
+					currentStatusMessage = [...args];
+					writeStatusMessage();
+				} else {
+					currentStatusMessage = [name, ...args];
+					writeStatusMessage();
+				}
+		  }
+		: writeColored("<s> ", "", "")
+};

package/lib/web/JsonpMainTemplatePlugin.js

@@ -367,7 +367,7 @@ class JsonpMainTemplatePlugin {
 							"for(;i < chunkIds.length; i++) {",
 							Template.indent([
 								"chunkId = chunkIds[i];",
-								"if(installedChunks[chunkId]) {",
+								"if(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {",
 								Template.indent("resolves.push(installedChunks[chunkId][0]);"),
 								"}",
 								"installedChunks[chunkId] = 0;"

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.36.0",
+  "version": "4.39.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",
@@ -9,25 +9,25 @@
     "@webassemblyjs/helper-module-context": "1.8.5",
     "@webassemblyjs/wasm-edit": "1.8.5",
     "@webassemblyjs/wasm-parser": "1.8.5",
-    "acorn": "^6.2.0",
-    "ajv": "^6.1.0",
-    "ajv-keywords": "^3.1.0",
-    "chrome-trace-event": "^1.0.0",
+    "acorn": "^6.2.1",
+    "ajv": "^6.10.2",
+    "ajv-keywords": "^3.4.1",
+    "chrome-trace-event": "^1.0.2",
     "enhanced-resolve": "^4.1.0",
-    "eslint-scope": "^4.0.0",
+    "eslint-scope": "^4.0.3",
     "json-parse-better-errors": "^1.0.2",
-    "loader-runner": "^2.3.0",
-    "loader-utils": "^1.1.0",
-    "memory-fs": "~0.4.1",
-    "micromatch": "^3.1.8",
-    "mkdirp": "~0.5.0",
-    "neo-async": "^2.5.0",
-    "node-libs-browser": "^2.0.0",
+    "loader-runner": "^2.4.0",
+    "loader-utils": "^1.2.3",
+    "memory-fs": "^0.4.1",
+    "micromatch": "^3.1.10",
+    "mkdirp": "^0.5.1",
+    "neo-async": "^2.6.1",
+    "node-libs-browser": "^2.2.1",
     "schema-utils": "^1.0.0",
-    "tapable": "^1.1.0",
-    "terser-webpack-plugin": "^1.1.0",
-    "watchpack": "^1.5.0",
-    "webpack-sources": "^1.3.0"
+    "tapable": "^1.1.3",
+    "terser-webpack-plugin": "^1.4.1",
+    "watchpack": "^1.6.0",
+    "webpack-sources": "^1.4.1"
   },
   "devDependencies": {
     "@types/node": "^10.12.21",
@@ -53,8 +53,6 @@
     "husky": "^1.1.3",
     "i18n-webpack-plugin": "^1.0.0",
     "istanbul": "^0.4.5",
-    "jade": "^1.11.0",
-    "jade-loader": "~0.8.0",
     "jest": "24.1.0",
     "jest-junit": "^6.2.1",
     "json-loader": "^0.5.7",
@@ -64,7 +62,7 @@
     "lint-staged": "^8.0.4",
     "lodash": "^4.17.4",
     "prettier": "^1.14.3",
-    "pug": "^2.0.3",
+    "pug": "^2.0.4",
     "pug-loader": "^2.4.0",
     "raw-loader": "^1.0.0",
     "react": "^16.8.0",