webpack 2.1.0-beta.21 → 2.1.0-beta.25

package/lib/HotModuleReplacementPlugin.js

@@ -194,75 +194,78 @@ HotModuleReplacementPlugin.prototype.apply = function(compiler) {
 			]);
 		});
 
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			parser.plugin("expression __webpack_hash__", function(expr) {
+				var dep = new ConstDependency("__webpack_require__.h()", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.plugin("evaluate typeof __webpack_hash__", function(expr) {
+				return new BasicEvaluatedExpression().setString("string").setRange(expr.range);
+			});
+			parser.plugin("evaluate Identifier module.hot", function(expr) {
+				return new BasicEvaluatedExpression()
+					.setBoolean(!!this.state.compilation.hotUpdateChunkTemplate)
+					.setRange(expr.range);
+			});
+			parser.plugin("call module.hot.accept", function(expr) {
+				if(!this.state.compilation.hotUpdateChunkTemplate) return false;
+				if(expr.arguments.length >= 1) {
+					var arg = this.evaluateExpression(expr.arguments[0]);
+					var params = [],
+						requests = [];
+					if(arg.isString()) {
+						params = [arg];
+					} else if(arg.isArray()) {
+						params = arg.items.filter(function(param) {
+							return param.isString();
+						});
+					}
+					if(params.length > 0) {
+						params.forEach(function(param, idx) {
+							var request = param.string;
+							var dep = new ModuleHotAcceptDependency(request, param.range);
+							dep.optional = true;
+							dep.loc = Object.create(expr.loc);
+							dep.loc.index = idx;
+							this.state.module.addDependency(dep);
+							requests.push(request);
+						}.bind(this));
+						if(expr.arguments.length > 1)
+							this.applyPluginsBailResult("hot accept callback", expr.arguments[1], requests);
+						else
+							this.applyPluginsBailResult("hot accept without callback", expr, requests);
+					}
+				}
+			});
+			parser.plugin("call module.hot.decline", function(expr) {
+				if(!this.state.compilation.hotUpdateChunkTemplate) return false;
+				if(expr.arguments.length === 1) {
+					var arg = this.evaluateExpression(expr.arguments[0]);
+					var params = [];
+					if(arg.isString()) {
+						params = [arg];
+					} else if(arg.isArray()) {
+						params = arg.items.filter(function(param) {
+							return param.isString();
+						});
+					}
+					params.forEach(function(param, idx) {
+						var dep = new ModuleHotDeclineDependency(param.string, param.range);
+						dep.optional = true;
+						dep.loc = Object.create(expr.loc);
+						dep.loc.index = idx;
+						this.state.module.addDependency(dep);
+					}.bind(this));
+				}
+			});
+			parser.plugin("expression module.hot", function() {
+				return true;
+			});
+		});
 	});
-	compiler.parser.plugin("expression __webpack_hash__", function(expr) {
-		var dep = new ConstDependency("__webpack_require__.h()", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	compiler.parser.plugin("evaluate typeof __webpack_hash__", function(expr) {
-		return new BasicEvaluatedExpression().setString("string").setRange(expr.range);
-	});
-	compiler.parser.plugin("evaluate Identifier module.hot", function(expr) {
-		return new BasicEvaluatedExpression()
-			.setBoolean(!!this.state.compilation.hotUpdateChunkTemplate)
-			.setRange(expr.range);
-	});
-	compiler.parser.plugin("call module.hot.accept", function(expr) {
-		if(!this.state.compilation.hotUpdateChunkTemplate) return false;
-		if(expr.arguments.length >= 1) {
-			var arg = this.evaluateExpression(expr.arguments[0]);
-			var params = [],
-				requests = [];
-			if(arg.isString()) {
-				params = [arg];
-			} else if(arg.isArray()) {
-				params = arg.items.filter(function(param) {
-					return param.isString();
-				});
-			}
-			if(params.length > 0) {
-				params.forEach(function(param, idx) {
-					var request = param.string;
-					var dep = new ModuleHotAcceptDependency(request, param.range);
-					dep.optional = true;
-					dep.loc = Object.create(expr.loc);
-					dep.loc.index = idx;
-					this.state.module.addDependency(dep);
-					requests.push(request);
-				}.bind(this));
-				if(expr.arguments.length > 1)
-					this.applyPluginsBailResult("hot accept callback", expr.arguments[1], requests);
-				else
-					this.applyPluginsBailResult("hot accept without callback", expr, requests);
-			}
-		}
-	});
-	compiler.parser.plugin("call module.hot.decline", function(expr) {
-		if(!this.state.compilation.hotUpdateChunkTemplate) return false;
-		if(expr.arguments.length === 1) {
-			var arg = this.evaluateExpression(expr.arguments[0]);
-			var params = [];
-			if(arg.isString()) {
-				params = [arg];
-			} else if(arg.isArray()) {
-				params = arg.items.filter(function(param) {
-					return param.isString();
-				});
-			}
-			params.forEach(function(param, idx) {
-				var dep = new ModuleHotDeclineDependency(param.string, param.range);
-				dep.optional = true;
-				dep.loc = Object.create(expr.loc);
-				dep.loc.index = idx;
-				this.state.module.addDependency(dep);
-			}.bind(this));
-		}
-	});
-	compiler.parser.plugin("expression module.hot", function() {
-		return true;
-	});
+
 };
 
 var hotInitCode = Template.getFunctionContent(require("./HotModuleReplacement.runtime.js"));

package/lib/LibManifestPlugin.js

@@ -37,8 +37,7 @@ LibManifestPlugin.prototype.apply = function(compiler) {
 							obj[ident] = {
 								id: module.id,
 								meta: module.meta,
-								hasStarExport: HarmonyModulesHelpers.hasStarExport(module),
-								activeExports: HarmonyModulesHelpers.getActiveExports(module)
+								exports: Array.isArray(module.providedExports) ? module.providedExports : undefined
 							};
 						}
 					}

package/lib/LibraryTemplatePlugin.js

@@ -3,6 +3,7 @@
 	Author Tobias Koppers @sokra
 */
 var SetVarMainTemplatePlugin = require("./SetVarMainTemplatePlugin");
+var CommonJsHarmonyMainTemplatePlugin = require("./CommonJsHarmonyMainTemplatePlugin");
 
 function accessorToObjectAccess(accessor) {
 	return accessor.map(function(a) {
@@ -55,6 +56,9 @@ LibraryTemplatePlugin.prototype.apply = function(compiler) {
 			case "commonjs2":
 				compilation.apply(new SetVarMainTemplatePlugin("module.exports"));
 				break;
+			case "commonjs-module":
+				compilation.apply(new CommonJsHarmonyMainTemplatePlugin());
+				break;
 			case "amd":
 				var AmdMainTemplatePlugin = require("./AmdMainTemplatePlugin");
 				compilation.apply(new AmdMainTemplatePlugin(this.name));

package/lib/MainTemplate.js

@@ -7,19 +7,18 @@ var OriginalSource = require("webpack-sources").OriginalSource;
 var PrefixSource = require("webpack-sources").PrefixSource;
 var Template = require("./Template");
 
-/* require function shortcuts:
- * __webpack_require__.s = the module id of the entry point
- * __webpack_require__.c = the module cache
- * __webpack_require__.m = the module functions
- * __webpack_require__.p = the bundle public path
- * __webpack_require__.i = the identity function used for harmony imports
- * __webpack_require__.e = the chunk ensure function
- * __webpack_require__.d = the exported propery define getter function
- * __webpack_require__.o = Object.prototype.hasOwnProperty.call
- * __webpack_require__.n = compatibility get default export
- * __webpack_require__.h = the webpack hash
- * __webpack_require__.oe = the uncatched error handler for the webpack runtime
- */
+// require function shortcuts:
+// __webpack_require__.s = the module id of the entry point
+// __webpack_require__.c = the module cache
+// __webpack_require__.m = the module functions
+// __webpack_require__.p = the bundle public path
+// __webpack_require__.i = the identity function used for harmony imports
+// __webpack_require__.e = the chunk ensure function
+// __webpack_require__.d = the exported propery define getter function
+// __webpack_require__.o = Object.prototype.hasOwnProperty.call
+// __webpack_require__.n = compatibility get default export
+// __webpack_require__.h = the webpack hash
+// __webpack_require__.oe = the uncatched error handler for the webpack runtime
 
 function MainTemplate(outputOptions) {
 	Template.call(this, outputOptions);

package/lib/Module.js

@@ -20,6 +20,7 @@ function Module() {
 	this.index2 = null;
 	this.used = null;
 	this.usedExports = null;
+	this.providedExports = null;
 	this.chunks = [];
 	this.warnings = [];
 	this.dependenciesWarnings = [];
@@ -51,6 +52,7 @@ Module.prototype.disconnect = function() {
 	this.index2 = null;
 	this.used = null;
 	this.usedExports = null;
+	this.providedExports = null;
 	this.chunks.length = 0;
 	DependenciesBlock.prototype.disconnect.call(this);
 };
@@ -132,11 +134,17 @@ Module.prototype.isUsed = function(exportName) {
 	if(this.usedExports === true) return exportName;
 	var idx = this.usedExports.indexOf(exportName);
 	if(idx < 0) return false;
-	if(HarmonyModulesHelpers.isExportedByHarmony(this, exportName))
+	if(this.isProvided(exportName))
 		return Template.numberToIdentifer(idx);
 	return exportName;
 };
 
+Module.prototype.isProvided = function(exportName) {
+	if(!Array.isArray(this.providedExports))
+		return null;
+	return this.providedExports.indexOf(exportName) >= 0;
+};
+
 Module.prototype.toString = function() {
 	return "Module[" + (this.id || this.debugId) + "]";
 };
@@ -168,3 +176,4 @@ Module.prototype.readableIdentifier = null;
 Module.prototype.build = null;
 Module.prototype.source = null;
 Module.prototype.size = null;
+Module.prototype.nameForCondition = null;

package/lib/MovedToPluginWarningPlugin.js

@@ -12,6 +12,8 @@ MovedToPluginWarningPlugin.prototype.apply = function(compiler) {
 	var optionName = this.optionName;
 	var pluginName = this.pluginName;
 	compiler.plugin("compilation", function(compilation) {
-		compilation.warnings.push(new Error("webpack options:\nDEPRECATED option '" + optionName + "' will be moved to the " + pluginName + ". Use this instead.\nFor more info about the usage of the " + pluginName + " see https://webpack.github.io/docs/list-of-plugins.html"));
+		compilation.warnings.push(new Error("webpack options:\nDEPRECATED option '" + optionName + "' will be moved to the " + pluginName + ". " +
+			"Use this instead.\n" +
+			"For more info about the usage of the " + pluginName + " see https://webpack.github.io/docs/list-of-plugins.html"));
 	});
 };

package/lib/MultiCompiler.js

@@ -90,19 +90,93 @@ module.exports = MultiCompiler;
 MultiCompiler.prototype = Object.create(Tapable.prototype);
 MultiCompiler.prototype.constructor = MultiCompiler;
 
-MultiCompiler.prototype.watch = function(watchDelay, handler) {
-	var watchings = this.compilers.map(function(compiler) {
-		return compiler.watch(watchDelay, handler);
+function runWithDependencies(compilers, fn, callback) {
+	var fulfilledNames = {};
+	var remainingCompilers = compilers;
+
+	function isDependencyFulfilled(d) {
+		return fulfilledNames[d];
+	}
+
+	function getReadyCompilers() {
+		var readyCompilers = [];
+		var list = remainingCompilers;
+		remainingCompilers = [];
+		for(var i = 0; i < list.length; i++) {
+			var c = list[i];
+			var ready = !c.dependencies || c.dependencies.every(isDependencyFulfilled);
+			if(ready)
+				readyCompilers.push(c);
+			else
+				remainingCompilers.push(c);
+		}
+		return readyCompilers;
+	}
+
+	function runCompilers(callback) {
+		if(remainingCompilers.length === 0) return callback();
+		async.map(getReadyCompilers(), function(compiler, callback) {
+			fn(compiler, function(err) {
+				if(err) return callback(err);
+				fulfilledNames[compiler.name] = true;
+				runCompilers(callback);
+			});
+		}, callback);
+	}
+	runCompilers(callback);
+}
+
+MultiCompiler.prototype.watch = function(watchOptions, handler) {
+	var watchings = [];
+	var allStats = this.compilers.map(function() {
+		return null;
+	});
+	var compilerStatus = this.compilers.map(function() {
+		return false;
 	});
+
+	runWithDependencies(this.compilers, function(compiler, callback) {
+		var compilerIdx = this.compilers.indexOf(compiler);
+		var firstRun = true;
+		var watching = compiler.watch(watchOptions, function(err, stats) {
+			if(err)
+				handler(err);
+			if(stats) {
+				allStats[compilerIdx] = stats;
+				compilerStatus[compilerIdx] = true;
+				if(compilerStatus.every(Boolean)) {
+					var multiStats = new MultiStats(allStats);
+					handler(null, multiStats)
+				}
+			}
+			if(firstRun && !err) {
+				firstRun = false;
+				callback();
+			}
+		});
+		watchings.push(watching);
+	}.bind(this), function() {
+		// ignore
+	});
+
 	return new MultiWatching(watchings);
 };
 
 MultiCompiler.prototype.run = function(callback) {
-	async.map(this.compilers, function(compiler, callback) {
-		compiler.run(callback);
-	}, function(err, stats) {
+	var allStats = this.compilers.map(function() {
+		return null;
+	});
+
+	runWithDependencies(this.compilers, function(compiler, callback) {
+		var compilerIdx = this.compilers.indexOf(compiler);
+		compiler.run(function(err, stats) {
+			if(err) return callback(err);
+			allStats[compilerIdx] = stats;
+			callback();
+		});
+	}.bind(this), function(err) {
 		if(err) return callback(err);
-		callback(null, new MultiStats(stats));
+		callback(null, new MultiStats(allStats));
 	});
 };
 

package/lib/NodeStuffPlugin.js

@@ -15,97 +15,108 @@ function NodeStuffPlugin(options) {
 }
 module.exports = NodeStuffPlugin;
 NodeStuffPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	var options = this.options;
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
 
-	function ignore() {
-		return true;
-	}
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
 
-	function setConstant(expressionName, value) {
-		compiler.parser.plugin("expression " + expressionName, function() {
-			this.state.current.addVariable(expressionName, JSON.stringify(value));
-			return true;
-		});
-	}
+			if(parserOptions.node === false)
+				return;
 
-	function setModuleConstant(expressionName, fn) {
-		compiler.parser.plugin("expression " + expressionName, function() {
-			this.state.current.addVariable(expressionName, JSON.stringify(fn(this.state.module)));
-			return true;
-		});
-	}
-	var context = compiler.context;
-	if(this.options.__filename === "mock") {
-		setConstant("__filename", "/index.js");
-	} else if(this.options.__filename) {
-		setModuleConstant("__filename", function(module) {
-			return path.relative(context, module.resource);
-		});
-	}
-	compiler.parser.plugin("evaluate Identifier __filename", function(expr) {
-		if(!this.state.module) return;
-		var res = new BasicEvaluatedExpression();
-		var resource = this.state.module.resource;
-		var i = resource.indexOf("?");
-		res.setString(i < 0 ? resource : resource.substr(0, i));
-		res.setRange(expr.range);
-		return res;
-	});
-	if(this.options.__dirname === "mock") {
-		setConstant("__dirname", "/");
-	} else if(this.options.__dirname) {
-		setModuleConstant("__dirname", function(module) {
-			return path.relative(context, module.context);
-		});
-	}
-	compiler.parser.plugin("evaluate Identifier __dirname", function(expr) {
-		if(!this.state.module) return;
-		var res = new BasicEvaluatedExpression();
-		res.setString(this.state.module.context);
-		res.setRange(expr.range);
-		return res;
-	});
-	compiler.parser.plugin("expression require.main", function(expr) {
-		var dep = new ConstDependency("__webpack_require__.c[__webpack_require__.s]", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	compiler.parser.plugin("expression require.extensions", function(expr) {
-		var dep = new ConstDependency("(void 0)", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		if(!this.state.module) return;
-		this.state.module.warnings.push(new UnsupportedFeatureWarning(this.state.module, "require.extensions is not supported by webpack. Use a loader instead."));
-		return true;
-	});
-	compiler.parser.plugin("expression module.loaded", function(expr) {
-		var dep = new ConstDependency("module.l", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	compiler.parser.plugin("expression module.id", function(expr) {
-		var dep = new ConstDependency("module.i", expr.range);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-	compiler.parser.plugin("expression module.exports", ignore);
-	compiler.parser.plugin("evaluate Identifier module.hot", function(expr) {
-		return new BasicEvaluatedExpression().setBoolean(false).setRange(expr.range);
-	});
-	compiler.parser.plugin("expression module", function() {
-		var moduleJsPath = path.join(__dirname, "..", "buildin", "module.js");
-		if(this.state.module.context) {
-			moduleJsPath = path.relative(this.state.module.context, moduleJsPath);
-			if(!/^[A-Z]:/i.test(moduleJsPath)) {
-				moduleJsPath = "./" + moduleJsPath.replace(/\\/g, "/");
+			var localOptions = options;
+			if(parserOptions.node)
+				localOptions = Object.assign({}, localOptions, parserOptions.node);
+
+			function ignore() {
+				return true;
+			}
+
+			function setConstant(expressionName, value) {
+				parser.plugin("expression " + expressionName, function() {
+					this.state.current.addVariable(expressionName, JSON.stringify(value));
+					return true;
+				});
 			}
-		}
-		return ModuleParserHelpers.addParsedVariable(this, "module", "require(" + JSON.stringify(moduleJsPath) + ")(module)");
+
+			function setModuleConstant(expressionName, fn) {
+				parser.plugin("expression " + expressionName, function() {
+					this.state.current.addVariable(expressionName, JSON.stringify(fn(this.state.module)));
+					return true;
+				});
+			}
+			var context = compiler.context;
+			if(localOptions.__filename === "mock") {
+				setConstant("__filename", "/index.js");
+			} else if(localOptions.__filename) {
+				setModuleConstant("__filename", function(module) {
+					return path.relative(context, module.resource);
+				});
+			}
+			parser.plugin("evaluate Identifier __filename", function(expr) {
+				if(!this.state.module) return;
+				var res = new BasicEvaluatedExpression();
+				var resource = this.state.module.resource;
+				var i = resource.indexOf("?");
+				res.setString(i < 0 ? resource : resource.substr(0, i));
+				res.setRange(expr.range);
+				return res;
+			});
+			if(localOptions.__dirname === "mock") {
+				setConstant("__dirname", "/");
+			} else if(localOptions.__dirname) {
+				setModuleConstant("__dirname", function(module) {
+					return path.relative(context, module.context);
+				});
+			}
+			parser.plugin("evaluate Identifier __dirname", function(expr) {
+				if(!this.state.module) return;
+				var res = new BasicEvaluatedExpression();
+				res.setString(this.state.module.context);
+				res.setRange(expr.range);
+				return res;
+			});
+			parser.plugin("expression require.main", function(expr) {
+				var dep = new ConstDependency("__webpack_require__.c[__webpack_require__.s]", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.plugin("expression require.extensions", function(expr) {
+				var dep = new ConstDependency("(void 0)", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				if(!this.state.module) return;
+				this.state.module.warnings.push(new UnsupportedFeatureWarning(this.state.module, "require.extensions is not supported by webpack. Use a loader instead."));
+				return true;
+			});
+			parser.plugin("expression module.loaded", function(expr) {
+				var dep = new ConstDependency("module.l", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.plugin("expression module.id", function(expr) {
+				var dep = new ConstDependency("module.i", expr.range);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return true;
+			});
+			parser.plugin("expression module.exports", ignore);
+			parser.plugin("evaluate Identifier module.hot", function(expr) {
+				return new BasicEvaluatedExpression().setBoolean(false).setRange(expr.range);
+			});
+			parser.plugin("expression module", function() {
+				var moduleJsPath = path.join(__dirname, "..", "buildin", "module.js");
+				if(this.state.module.context) {
+					moduleJsPath = path.relative(this.state.module.context, moduleJsPath);
+					if(!/^[A-Z]:/i.test(moduleJsPath)) {
+						moduleJsPath = "./" + moduleJsPath.replace(/\\/g, "/");
+					}
+				}
+				return ModuleParserHelpers.addParsedVariable(this, "module", "require(" + JSON.stringify(moduleJsPath) + ")(module)");
+			});
+		});
 	});
 };

package/lib/NormalModule.js

@@ -75,6 +75,12 @@ NormalModule.prototype.libIdent = function(options) {
 	return contextify(options, this.userRequest);
 };
 
+NormalModule.prototype.nameForCondition = function() {
+	var idx = this.resource.indexOf("?");
+	if(idx >= 0) return this.resource.substr(0, idx);
+	return this.resource;
+};
+
 NormalModule.prototype.doBuild = function doBuild(options, compilation, resolver, fs, callback) {
 	this.cacheable = false;
 	var module = this;