Merge pull request webpack#8460 from webpack/refactor/node_polyfills

Do not polyfill node bindings by default

Author: sokra

buildin/global.js

@@ -764,10 +764,6 @@ export interface WebpackPluginInstance {
  * via the `definition` "NodeOptions".
  */
 export interface NodeOptions {
-	/**
-	 * Include a polyfill for the 'Buffer' variable
-	 */
-	Buffer?: false | true | "mock";
 	/**
 	 * Include a polyfill for the '__dirname' variable
 	 */
@@ -776,22 +772,10 @@ export interface NodeOptions {
 	 * Include a polyfill for the '__filename' variable
 	 */
 	__filename?: false | true | "mock";
-	/**
-	 * Include a polyfill for the 'console' variable
-	 */
-	console?: false | true | "mock";
 	/**
 	 * Include a polyfill for the 'global' variable
 	 */
 	global?: boolean;
-	/**
-	 * Include a polyfill for the 'process' variable
-	 */
-	process?: false | true | "mock";
-	/**
-	 * Include a polyfill for the node.js module
-	 */
-	[k: string]: false | true | "mock" | "empty";
 }
 /**
  * Enables/Disables integrated optimizations

declarations/WebpackOptions.d.ts

@@ -9,14 +9,74 @@ const WebpackError = require("./WebpackError");
 
 /** @typedef {import("./Module")} Module */
 
+const previouslyPolyfilledBuiltinModules = {
+	assert: "assert",
+	buffer: "buffer",
+	console: "console-browserify",
+	constants: "constants-browserify",
+	crypto: "crypto-browserify",
+	___domain: "___domain-browser",
+	events: "events",
+	http: "stream-http",
+	https: "https-browserify",
+	os: "os-browserify/browser",
+	path: "path-browserify",
+	punycode: "punycode",
+	process: "process/browser",
+	querystring: "querystring-es3",
+	stream: "stream-browserify",
+	_stream_duplex: "readable-stream/duplex",
+	_stream_passthrough: "readable-stream/passthrough",
+	_stream_readable: "readable-stream/readable",
+	_stream_transform: "readable-stream/transform",
+	_stream_writable: "readable-stream/writable",
+	string_decoder: "string_decoder",
+	sys: "util",
+	timers: "timers-browserify",
+	tty: "tty-browserify",
+	url: "url",
+	util: "util",
+	vm: "vm-browserify",
+	zlib: "browserify-zlib"
+};
+
 class ModuleNotFoundError extends WebpackError {
 	/**
 	 * @param {Module} module module tied to dependency
 	 * @param {Error&any} err error thrown
 	 * @param {TODO} loc ___location of dependency
 	 */
 	constructor(module, err, loc) {
-		super("Module not found: " + err);
+		let message = `Module not found: ${err.toString()}`;
+
+		// TODO remove in webpack 6
+		const match = err.message.match(/Can't resolve '([^']+)'/);
+		if (match) {
+			const request = match[1];
+			const alias = previouslyPolyfilledBuiltinModules[request];
+			if (alias) {
+				const pathIndex = alias.indexOf("/");
+				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
+				message +=
+					"\n\n" +
+					"BREAKING CHANGE: " +
+					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
+					"This is no longer the case. Verify if you need these module and configure a polyfill for it.\n\n";
+				if (request !== alias) {
+					message +=
+						"If you want to include a polyfill, you need to:\n" +
+						`\t- add an alias 'resolve.alias: { "${request}": "${alias}" }'\n` +
+						`\t- install '${dependency}'\n`;
+				} else {
+					message += `If you want to include a polyfill, you need to install '${dependency}'.\n`;
+				}
+				message +=
+					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
+					`\tresolve.alias: { "${request}": false }`;
+			}
+		}
+
+		super(message);
 
 		this.name = "ModuleNotFoundError";
 		this.details = err.details;

lib/ModuleNotFoundError.js

@@ -125,6 +125,11 @@ exports.startup = "__webpack_require__.x";
  */
 exports.interceptModuleExecution = "__webpack_require__.i";
 
+/**
+ * the global object
+ */
+exports.global = "__webpack_require__.g";
+
 /**
  * the filename of the HMR manifest
  */

lib/RuntimeGlobals.js

@@ -12,6 +12,7 @@ const DefinePropertyGetterRuntimeModule = require("./runtime/DefinePropertyGette
 const EnsureChunkRuntimeModule = require("./runtime/EnsureChunkRuntimeModule");
 const GetChunkFilenameRuntimeModule = require("./runtime/GetChunkFilenameRuntimeModule");
 const GetMainFilenameRuntimeModule = require("./runtime/GetMainFilenameRuntimeModule");
+const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule");
 
@@ -34,6 +35,7 @@ const DEPENDENCIES = {
 	[RuntimeGlobals.ensureChunk]: [RuntimeGlobals.require],
 	[RuntimeGlobals.entryModuleId]: [RuntimeGlobals.require],
 	[RuntimeGlobals.getFullHash]: [RuntimeGlobals.require],
+	[RuntimeGlobals.global]: [RuntimeGlobals.require],
 	[RuntimeGlobals.makeNamespaceObject]: [RuntimeGlobals.require],
 	[RuntimeGlobals.moduleCache]: [RuntimeGlobals.require],
 	[RuntimeGlobals.moduleFactories]: [RuntimeGlobals.require],
@@ -103,6 +105,12 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.global)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.getChunkScriptFilename)
 				.tap("RuntimePlugin", (chunk, set) => {

lib/RuntimePlugin.js

@@ -203,11 +203,7 @@ class WebpackOptionsDefaulter extends OptionsDefaulter {
 				return Object.assign({}, value);
 			}
 		});
-		this.set("node.console", false);
-		this.set("node.process", true);
-		this.set("node.global", true);
-		this.set("node.Buffer", true);
-		this.set("node.setImmediate", true);
+		this.set("node.global", false);
 		this.set("node.__filename", "mock");
 		this.set("node.__dirname", "mock");
 

lib/WebpackOptionsDefaulter.js

@@ -5,14 +5,16 @@
 
 "use strict";
 
-const AliasPlugin = require("enhanced-resolve/lib/AliasPlugin");
-const nodeLibsBrowser = require("node-libs-browser");
-const { getModulePath } = require("../JavascriptParserHelpers");
-const ProvidedDependency = require("../dependencies/ProvidedDependency");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const ConstDependency = require("../dependencies/ConstDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").NodeOptions} NodeOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 module.exports = class NodeSourcePlugin {
+	/**
+	 * @param {NodeOptions | false} options plugin options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -28,112 +30,32 @@ module.exports = class NodeSourcePlugin {
 			return;
 		}
 
-		const getPathToModule = (module, type) => {
-			if (type === true || (type === undefined && nodeLibsBrowser[module])) {
-				if (!nodeLibsBrowser[module]) {
-					throw new Error(
-						`No browser version for node.js core module ${module} available`
-					);
-				}
-				return nodeLibsBrowser[module];
-			} else if (type === "mock") {
-				return require.resolve(`node-libs-browser/mock/${module}`);
-			} else if (type === "empty") {
-				return require.resolve("node-libs-browser/mock/empty");
-			} else {
-				return module;
-			}
-		};
-
-		const addExpression = (parser, module, identifier, path, type) => {
-			parser.hooks.expression.for(identifier).tap("NodeSourcePlugin", expr => {
-				if (
-					parser.state.module &&
-					parser.state.module.resource === getPathToModule(module, type)
-				) {
-					return;
-				}
-				const dep = new ProvidedDependency(
-					getModulePath(
-						parser.state.module.context,
-						getPathToModule(module, type)
-					),
-					identifier,
-					path,
-					expr.range
-				);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-				return true;
-			});
-		};
-
 		compiler.hooks.compilation.tap(
 			"NodeSourcePlugin",
 			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ProvidedDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ProvidedDependency,
-					new ProvidedDependency.Template()
-				);
-
 				const handler = (parser, parserOptions) => {
 					if (parserOptions.node === false) return;
 
 					let localOptions = options;
 					if (parserOptions.node) {
 						localOptions = Object.assign({}, localOptions, parserOptions.node);
 					}
+
 					if (localOptions.global) {
 						parser.hooks.expression
 							.for("global")
 							.tap("NodeSourcePlugin", expr => {
-								const dep = new ProvidedDependency(
-									getModulePath(
-										parser.state.module.context,
-										require.resolve("../../buildin/global")
-									),
-									"global",
-									null,
-									expr.range
+								const dep = new ConstDependency(
+									RuntimeGlobals.global,
+									expr.range,
+									[RuntimeGlobals.global]
 								);
 								dep.loc = expr.loc;
 								parser.state.module.addDependency(dep);
 							});
 					}
-					if (localOptions.process) {
-						const processType = localOptions.process;
-						addExpression(parser, "process", "process", null, processType);
-					}
-					if (localOptions.console) {
-						const consoleType = localOptions.console;
-						addExpression(parser, "console", "console", null, consoleType);
-					}
-					const bufferType = localOptions.Buffer;
-					if (bufferType) {
-						addExpression(parser, "buffer", "Buffer", ["Buffer"], bufferType);
-					}
-					if (localOptions.setImmediate) {
-						const setImmediateType = localOptions.setImmediate;
-						addExpression(
-							parser,
-							"timers",
-							"setImmediate",
-							["setImmediate"],
-							setImmediateType
-						);
-						addExpression(
-							parser,
-							"timers",
-							"clearImmediate",
-							["clearImmediate"],
-							setImmediateType
-						);
-					}
 				};
+
 				normalModuleFactory.hooks.parser
 					.for("javascript/auto")
 					.tap("NodeSourcePlugin", handler);
@@ -145,24 +67,5 @@ module.exports = class NodeSourcePlugin {
 					.tap("NodeSourcePlugin", handler);
 			}
 		);
-		compiler.hooks.afterResolvers.tap("NodeSourcePlugin", compiler => {
-			for (const lib of Object.keys(nodeLibsBrowser)) {
-				if (options[lib] !== false) {
-					compiler.resolverFactory.hooks.resolver
-						.for("normal")
-						.tap("NodeSourcePlugin", resolver => {
-							new AliasPlugin(
-								"described-resolve",
-								{
-									name: lib,
-									onlyModule: true,
-									alias: getPathToModule(lib, options[lib])
-								},
-								"resolve"
-							).apply(resolver);
-						});
-				}
-			}
-		});
 	}
 };

lib/node/NodeSourcePlugin.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+class GlobalRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("global");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.global} = (function() {`,
+			Template.indent([
+				// This works in non-strict mode
+				"var g = (function() { return this; })();",
+				"try {",
+				Template.indent(
+					// This works if eval is allowed (see CSP)
+					"g = g || new Function('return this')();"
+				),
+				"} catch (e) {",
+				Template.indent(
+					// This works if the window reference is available
+					"if (typeof window === 'object') g = window;"
+				),
+				"}",
+				// g can still be `undefined`, but nothing to do about it...
+				// We return `undefined`, instead of nothing here, so it's
+				// easier to handle this case:
+				//   if (!global) { … }
+				"return g;"
+			]),
+			"})();"
+		]);
+	}
+}
+
+module.exports = GlobalRuntimeModule;