webpack 3.3.0 → 3.5.1

package/bin/webpack.js

@@ -146,228 +146,244 @@ yargs.options({
 	}
 });
 
-var argv = yargs.argv;
-
-if(argv.verbose) {
-	argv["display"] = "verbose";
-}
-
-var options = require("./convert-argv")(yargs, argv);
-
-function ifArg(name, fn, init) {
-	if(Array.isArray(argv[name])) {
-		if(init) init();
-		argv[name].forEach(fn);
-	} else if(typeof argv[name] !== "undefined") {
-		if(init) init();
-		fn(argv[name], -1);
-	}
-}
-
-function processOptions(options) {
-	// process Promise
-	if(typeof options.then === "function") {
-		options.then(processOptions).catch(function(err) {
-			console.error(err.stack || err);
-			process.exit(1); // eslint-disable-line
-		});
+// yargs will terminate the process early when the user uses help or version.
+// This causes large help outputs to be cut short (https://github.com/nodejs/node/wiki/API-changes-between-v0.10-and-v4#process).
+// To prevent this we use the yargs.parse API and exit the process normally
+yargs.parse(process.argv.slice(2), (err, argv, output) => {
+
+	// arguments validation failed
+	if(err && output) {
+		console.error(output);
+		process.exitCode = 1;
 		return;
 	}
 
-	var firstOptions = [].concat(options)[0];
-	var statsPresetToOptions = require("../lib/Stats.js").presetToOptions;
+	// help or version info
+	if(output) {
+		console.log(output);
+		return;
+	}
 
-	var outputOptions = options.stats;
-	if(typeof outputOptions === "boolean" || typeof outputOptions === "string") {
-		outputOptions = statsPresetToOptions(outputOptions);
-	} else if(!outputOptions) {
-		outputOptions = {};
+	if(argv.verbose) {
+		argv["display"] = "verbose";
 	}
 
-	ifArg("display", function(preset) {
-		outputOptions = statsPresetToOptions(preset);
-	});
+	var options = require("./convert-argv")(yargs, argv);
 
-	outputOptions = Object.create(outputOptions);
-	if(Array.isArray(options) && !outputOptions.children) {
-		outputOptions.children = options.map(o => o.stats);
+	function ifArg(name, fn, init) {
+		if(Array.isArray(argv[name])) {
+			if(init) init();
+			argv[name].forEach(fn);
+		} else if(typeof argv[name] !== "undefined") {
+			if(init) init();
+			fn(argv[name], -1);
+		}
 	}
-	if(typeof outputOptions.context === "undefined")
-		outputOptions.context = firstOptions.context;
 
-	ifArg("json", function(bool) {
-		if(bool)
-			outputOptions.json = bool;
-	});
+	function processOptions(options) {
+		// process Promise
+		if(typeof options.then === "function") {
+			options.then(processOptions).catch(function(err) {
+				console.error(err.stack || err);
+				process.exit(1); // eslint-disable-line
+			});
+			return;
+		}
 
-	if(typeof outputOptions.colors === "undefined")
-		outputOptions.colors = require("supports-color");
+		var firstOptions = [].concat(options)[0];
+		var statsPresetToOptions = require("../lib/Stats.js").presetToOptions;
 
-	ifArg("sort-modules-by", function(value) {
-		outputOptions.modulesSort = value;
-	});
+		var outputOptions = options.stats;
+		if(typeof outputOptions === "boolean" || typeof outputOptions === "string") {
+			outputOptions = statsPresetToOptions(outputOptions);
+		} else if(!outputOptions) {
+			outputOptions = {};
+		}
 
-	ifArg("sort-chunks-by", function(value) {
-		outputOptions.chunksSort = value;
-	});
+		ifArg("display", function(preset) {
+			outputOptions = statsPresetToOptions(preset);
+		});
 
-	ifArg("sort-assets-by", function(value) {
-		outputOptions.assetsSort = value;
-	});
+		outputOptions = Object.create(outputOptions);
+		if(Array.isArray(options) && !outputOptions.children) {
+			outputOptions.children = options.map(o => o.stats);
+		}
+		if(typeof outputOptions.context === "undefined")
+			outputOptions.context = firstOptions.context;
 
-	ifArg("display-exclude", function(value) {
-		outputOptions.exclude = value;
-	});
+		ifArg("json", function(bool) {
+			if(bool)
+				outputOptions.json = bool;
+		});
 
-	if(!outputOptions.json) {
-		if(typeof outputOptions.cached === "undefined")
-			outputOptions.cached = false;
-		if(typeof outputOptions.cachedAssets === "undefined")
-			outputOptions.cachedAssets = false;
+		if(typeof outputOptions.colors === "undefined")
+			outputOptions.colors = require("supports-color");
 
-		ifArg("display-chunks", function(bool) {
-			if(bool) {
-				outputOptions.modules = false;
-				outputOptions.chunks = true;
-				outputOptions.chunkModules = true;
-			}
+		ifArg("sort-modules-by", function(value) {
+			outputOptions.modulesSort = value;
 		});
 
-		ifArg("display-entrypoints", function(bool) {
-			if(bool)
-				outputOptions.entrypoints = true;
+		ifArg("sort-chunks-by", function(value) {
+			outputOptions.chunksSort = value;
 		});
 
-		ifArg("display-reasons", function(bool) {
-			if(bool)
-				outputOptions.reasons = true;
+		ifArg("sort-assets-by", function(value) {
+			outputOptions.assetsSort = value;
 		});
 
-		ifArg("display-depth", function(bool) {
-			if(bool)
-				outputOptions.depth = true;
+		ifArg("display-exclude", function(value) {
+			outputOptions.exclude = value;
 		});
 
-		ifArg("display-used-exports", function(bool) {
-			if(bool)
-				outputOptions.usedExports = true;
-		});
+		if(!outputOptions.json) {
+			if(typeof outputOptions.cached === "undefined")
+				outputOptions.cached = false;
+			if(typeof outputOptions.cachedAssets === "undefined")
+				outputOptions.cachedAssets = false;
+
+			ifArg("display-chunks", function(bool) {
+				if(bool) {
+					outputOptions.modules = false;
+					outputOptions.chunks = true;
+					outputOptions.chunkModules = true;
+				}
+			});
 
-		ifArg("display-provided-exports", function(bool) {
-			if(bool)
-				outputOptions.providedExports = true;
-		});
+			ifArg("display-entrypoints", function(bool) {
+				if(bool)
+					outputOptions.entrypoints = true;
+			});
 
-		ifArg("display-optimization-bailout", function(bool) {
-			if(bool)
-				outputOptions.optimizationBailout = bool;
-		});
+			ifArg("display-reasons", function(bool) {
+				if(bool)
+					outputOptions.reasons = true;
+			});
 
-		ifArg("display-error-details", function(bool) {
-			if(bool)
-				outputOptions.errorDetails = true;
-		});
+			ifArg("display-depth", function(bool) {
+				if(bool)
+					outputOptions.depth = true;
+			});
 
-		ifArg("display-origins", function(bool) {
-			if(bool)
-				outputOptions.chunkOrigins = true;
-		});
+			ifArg("display-used-exports", function(bool) {
+				if(bool)
+					outputOptions.usedExports = true;
+			});
 
-		ifArg("display-max-modules", function(value) {
-			outputOptions.maxModules = +value;
-		});
+			ifArg("display-provided-exports", function(bool) {
+				if(bool)
+					outputOptions.providedExports = true;
+			});
 
-		ifArg("display-cached", function(bool) {
-			if(bool)
-				outputOptions.cached = true;
-		});
+			ifArg("display-optimization-bailout", function(bool) {
+				if(bool)
+					outputOptions.optimizationBailout = bool;
+			});
 
-		ifArg("display-cached-assets", function(bool) {
-			if(bool)
-				outputOptions.cachedAssets = true;
-		});
+			ifArg("display-error-details", function(bool) {
+				if(bool)
+					outputOptions.errorDetails = true;
+			});
 
-		if(!outputOptions.exclude)
-			outputOptions.exclude = ["node_modules", "bower_components", "components"];
+			ifArg("display-origins", function(bool) {
+				if(bool)
+					outputOptions.chunkOrigins = true;
+			});
 
-		if(argv["display-modules"]) {
-			outputOptions.maxModules = Infinity;
-			outputOptions.exclude = undefined;
-			outputOptions.modules = true;
-		}
-	}
+			ifArg("display-max-modules", function(value) {
+				outputOptions.maxModules = +value;
+			});
 
-	ifArg("hide-modules", function(bool) {
-		if(bool) {
-			outputOptions.modules = false;
-			outputOptions.chunkModules = false;
-		}
-	});
-
-	var webpack = require("../lib/webpack.js");
-
-	Error.stackTraceLimit = 30;
-	var lastHash = null;
-	var compiler;
-	try {
-		compiler = webpack(options);
-	} catch(e) {
-		var WebpackOptionsValidationError = require("../lib/WebpackOptionsValidationError");
-		if(e instanceof WebpackOptionsValidationError) {
-			if(argv.color)
-				console.error("\u001b[1m\u001b[31m" + e.message + "\u001b[39m\u001b[22m");
-			else
-				console.error(e.message);
-			process.exit(1); // eslint-disable-line no-process-exit
-		}
-		throw e;
-	}
+			ifArg("display-cached", function(bool) {
+				if(bool)
+					outputOptions.cached = true;
+			});
 
-	if(argv.progress) {
-		var ProgressPlugin = require("../lib/ProgressPlugin");
-		compiler.apply(new ProgressPlugin({
-			profile: argv.profile
-		}));
-	}
+			ifArg("display-cached-assets", function(bool) {
+				if(bool)
+					outputOptions.cachedAssets = true;
+			});
+
+			if(!outputOptions.exclude)
+				outputOptions.exclude = ["node_modules", "bower_components", "components"];
 
-	function compilerCallback(err, stats) {
-		if(!options.watch || err) {
-			// Do not keep cache anymore
-			compiler.purgeInputFileSystem();
+			if(argv["display-modules"]) {
+				outputOptions.maxModules = Infinity;
+				outputOptions.exclude = undefined;
+				outputOptions.modules = true;
+			}
 		}
-		if(err) {
-			lastHash = null;
-			console.error(err.stack || err);
-			if(err.details) console.error(err.details);
-			process.exit(1); // eslint-disable-line
+
+		ifArg("hide-modules", function(bool) {
+			if(bool) {
+				outputOptions.modules = false;
+				outputOptions.chunkModules = false;
+			}
+		});
+
+		var webpack = require("../lib/webpack.js");
+
+		Error.stackTraceLimit = 30;
+		var lastHash = null;
+		var compiler;
+		try {
+			compiler = webpack(options);
+		} catch(e) {
+			var WebpackOptionsValidationError = require("../lib/WebpackOptionsValidationError");
+			if(e instanceof WebpackOptionsValidationError) {
+				if(argv.color)
+					console.error("\u001b[1m\u001b[31m" + e.message + "\u001b[39m\u001b[22m");
+				else
+					console.error(e.message);
+				process.exit(1); // eslint-disable-line no-process-exit
+			}
+			throw e;
 		}
-		if(outputOptions.json) {
-			process.stdout.write(JSON.stringify(stats.toJson(outputOptions), null, 2) + "\n");
-		} else if(stats.hash !== lastHash) {
-			lastHash = stats.hash;
-			var statsString = stats.toString(outputOptions);
-			if(statsString)
-				process.stdout.write(statsString + "\n");
+
+		if(argv.progress) {
+			var ProgressPlugin = require("../lib/ProgressPlugin");
+			compiler.apply(new ProgressPlugin({
+				profile: argv.profile
+			}));
 		}
-		if(!options.watch && stats.hasErrors()) {
-			process.on("exit", function() {
-				process.exit(2); // eslint-disable-line
-			});
+
+		function compilerCallback(err, stats) {
+			if(!options.watch || err) {
+				// Do not keep cache anymore
+				compiler.purgeInputFileSystem();
+			}
+			if(err) {
+				lastHash = null;
+				console.error(err.stack || err);
+				if(err.details) console.error(err.details);
+				process.exit(1); // eslint-disable-line
+			}
+			if(outputOptions.json) {
+				process.stdout.write(JSON.stringify(stats.toJson(outputOptions), null, 2) + "\n");
+			} else if(stats.hash !== lastHash) {
+				lastHash = stats.hash;
+				var statsString = stats.toString(outputOptions);
+				if(statsString)
+					process.stdout.write(statsString + "\n");
+			}
+			if(!options.watch && stats.hasErrors()) {
+				process.exitCode = 2;
+			}
 		}
+		if(firstOptions.watch || options.watch) {
+			var watchOptions = firstOptions.watchOptions || firstOptions.watch || options.watch || {};
+			if(watchOptions.stdin) {
+				process.stdin.on("end", function() {
+					process.exit(); // eslint-disable-line
+				});
+				process.stdin.resume();
+			}
+			compiler.watch(watchOptions, compilerCallback);
+			console.log("\nWebpack is watching the files…\n");
+		} else
+			compiler.run(compilerCallback);
+
 	}
-	if(firstOptions.watch || options.watch) {
-		var watchOptions = firstOptions.watchOptions || firstOptions.watch || options.watch || {};
-		if(watchOptions.stdin) {
-			process.stdin.on("end", function() {
-				process.exit(0); // eslint-disable-line
-			});
-			process.stdin.resume();
-		}
-		compiler.watch(watchOptions, compilerCallback);
-		console.log("\nWebpack is watching the files…\n");
-	} else
-		compiler.run(compilerCallback);
 
-}
+	processOptions(options);
 
-processOptions(options);
+});

package/lib/ContextModule.js

@@ -140,8 +140,13 @@ class ContextModule extends Module {
 					this.addBlock(block);
 				}
 
-			} else {
+			} else if(this.async === "weak" || this.async === "async-weak") {
+
+				// we mark all dependencies as weak
+				dependencies.forEach(dep => dep.weak = true);
+				this.dependencies = dependencies;
 
+			} else {
 				// if we are lazy create a new async dependency block per dependency
 				// and add all blocks to this context
 				dependencies.forEach((dep, idx) => {
@@ -198,6 +203,58 @@ module.exports = webpackContext;
 webpackContext.id = ${JSON.stringify(id)};`;
 	}
 
+	getWeakSyncSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	if(!__webpack_require__.m[id])
+		throw new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+	return __webpack_require__(id);
+};
+function webpackContextResolve(req) {
+	var id = map[req];
+	if(!(id + 1)) // check for number or string
+		throw new Error("Cannot find module '" + req + "'.");
+	return id;
+};
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+webpackContext.id = ${JSON.stringify(id)};
+module.exports = webpackContext;`;
+	}
+
+	getAsyncWeakSource(dependencies, id) {
+		const map = this.getUserRequestMap(dependencies);
+
+		return `var map = ${JSON.stringify(map, null, "\t")};
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(function(id) {
+		if(!__webpack_require__.m[id])
+			throw new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+		return __webpack_require__(id);
+	});
+};
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncatched exception popping up in devtools
+	return Promise.resolve().then(function() {
+		var id = map[req];
+		if(!(id + 1)) // check for number or string
+			throw new Error("Cannot find module '" + req + "'.");
+		return id;
+	});
+};
+webpackAsyncContext.keys = function webpackAsyncContextKeys() {
+	return Object.keys(map);
+};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+	}
+
 	getEagerSource(dependencies, id) {
 		const map = this.getUserRequestMap(dependencies);
 		return `var map = ${JSON.stringify(map, null, "\t")};
@@ -205,20 +262,21 @@ function webpackAsyncContext(req) {
 	return webpackAsyncContextResolve(req).then(__webpack_require__);
 };
 function webpackAsyncContextResolve(req) {
-	return new Promise(function(resolve, reject) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncatched exception popping up in devtools
+	return Promise.resolve().then(function() {
 		var id = map[req];
 		if(!(id + 1)) // check for number or string
-			reject(new Error("Cannot find module '" + req + "'."));
-		else
-			resolve(id);
+			throw new Error("Cannot find module '" + req + "'.");
+		return id;
 	});
 };
 webpackAsyncContext.keys = function webpackAsyncContextKeys() {
 	return Object.keys(map);
 };
 webpackAsyncContext.resolve = webpackAsyncContextResolve;
-module.exports = webpackAsyncContext;
-webpackAsyncContext.id = ${JSON.stringify(id)};`;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	getLazyOnceSource(block, dependencies, id, outputOptions, requestShortener) {
@@ -240,8 +298,8 @@ webpackAsyncContext.keys = function webpackAsyncContextKeys() {
 	return Object.keys(map);
 };
 webpackAsyncContext.resolve = webpackAsyncContextResolve;
-module.exports = webpackAsyncContext;
-webpackAsyncContext.id = ${JSON.stringify(id)};`;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	getLazySource(blocks, id) {
@@ -282,8 +340,8 @@ function webpackAsyncContext(req) {
 webpackAsyncContext.keys = function webpackAsyncContextKeys() {
 	return Object.keys(map);
 };
-module.exports = webpackAsyncContext;
-webpackAsyncContext.id = ${JSON.stringify(id)};`;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	getSourceForEmptyContext(id) {
@@ -298,7 +356,11 @@ webpackEmptyContext.id = ${JSON.stringify(id)};`;
 
 	getSourceForEmptyAsyncContext(id) {
 		return `function webpackEmptyAsyncContext(req) {
-	return new Promise(function(resolve, reject) { reject(new Error("Cannot find module '" + req + "'.")); });
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncatched exception popping up in devtools
+	return Promise.resolve().then(function() {
+		throw new Error("Cannot find module '" + req + "'.");
+	});
 }
 webpackEmptyAsyncContext.keys = function() { return []; };
 webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
@@ -318,13 +380,25 @@ webpackEmptyAsyncContext.id = ${JSON.stringify(id)};`;
 				return this.getEagerSource(this.dependencies, this.id);
 			}
 			return this.getSourceForEmptyAsyncContext(this.id);
-		} else if(asyncMode === "lazy-once") {
+		}
+		if(asyncMode === "lazy-once") {
 			const block = this.blocks[0];
 			if(block) {
 				return this.getLazyOnceSource(block, block.dependencies, this.id, outputOptions, requestShortener);
 			}
 			return this.getSourceForEmptyAsyncContext(this.id);
 		}
+		if(asyncMode === "async-weak") {
+			if(this.dependencies && this.dependencies.length > 0) {
+				return this.getAsyncWeakSource(this.dependencies, this.id);
+			}
+			return this.getSourceForEmptyAsyncContext(this.id);
+		}
+		if(asyncMode === "weak") {
+			if(this.dependencies && this.dependencies.length > 0) {
+				return this.getWeakSyncSource(this.dependencies, this.id);
+			}
+		}
 		if(this.dependencies && this.dependencies.length > 0) {
 			return this.getSyncSource(this.dependencies, this.id);
 		}

package/lib/DelegatedModule.js

@@ -9,20 +9,26 @@ const OriginalSource = require("webpack-sources").OriginalSource;
 const RawSource = require("webpack-sources").RawSource;
 const WebpackMissingModule = require("./dependencies/WebpackMissingModule");
 const DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+const DelegatedExportsDependency = require("./dependencies/DelegatedExportsDependency");
 
 class DelegatedModule extends Module {
-	constructor(sourceRequest, data, type, userRequest) {
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
 		super();
 		this.sourceRequest = sourceRequest;
 		this.request = data.id;
 		this.meta = data.meta;
 		this.type = type;
+		this.originalRequest = originalRequest;
 		this.userRequest = userRequest;
 		this.built = false;
 		this.delegated = true;
 		this.delegateData = data;
 	}
 
+	libIdent(options) {
+		return typeof this.originalRequest === "string" ? this.originalRequest : this.originalRequest.libIdent(options);
+	}
+
 	identifier() {
 		return `delegated ${JSON.stringify(this.request)} from ${this.sourceRequest}`;
 	}
@@ -38,10 +44,10 @@ class DelegatedModule extends Module {
 	build(options, compilation, resolver, fs, callback) {
 		this.built = true;
 		this.builtTime = Date.now();
-		this.usedExports = true;
-		this.providedExports = this.delegateData.exports || true;
+		this.cacheable = true;
 		this.dependencies.length = 0;
 		this.addDependency(new DelegatedSourceDependency(this.sourceRequest));
+		this.addDependency(new DelegatedExportsDependency(this, this.delegateData.exports || true));
 		callback();
 	}
 
@@ -57,7 +63,7 @@ class DelegatedModule extends Module {
 		if(!sourceModule) {
 			str = WebpackMissingModule.moduleCode(this.sourceRequest);
 		} else {
-			str = `module.exports = (__webpack_require__(${sourceModule.id}))`;
+			str = `module.exports = (__webpack_require__(${JSON.stringify(sourceModule.id)}))`;
 
 			switch(this.type) {
 				case "require":

package/lib/DelegatedModuleFactoryPlugin.js

@@ -29,13 +29,14 @@ class DelegatedModuleFactoryPlugin {
 					let resolved;
 					if(innerRequest in this.options.content) {
 						resolved = this.options.content[innerRequest];
-						return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, innerRequest));
+						return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, innerRequest, request));
 					}
 					for(let i = 0; i < this.options.extensions.length; i++) {
-						const requestPlusExt = innerRequest + this.options.extensions[i];
+						const extension = this.options.extensions[i];
+						const requestPlusExt = innerRequest + extension;
 						if(requestPlusExt in this.options.content) {
 							resolved = this.options.content[requestPlusExt];
-							return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, requestPlusExt));
+							return callback(null, new DelegatedModule(this.options.source, resolved, this.options.type, requestPlusExt, request + extension));
 						}
 					}
 				}
@@ -47,7 +48,7 @@ class DelegatedModuleFactoryPlugin {
 					const request = module.libIdent(this.options);
 					if(request && request in this.options.content) {
 						const resolved = this.options.content[request];
-						return new DelegatedModule(this.options.source, resolved, this.options.type, request);
+						return new DelegatedModule(this.options.source, resolved, this.options.type, request, module);
 					}
 				}
 				return module;