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

package/lib/ConstPlugin.js

@@ -16,44 +16,47 @@ function ConstPlugin() {}
 module.exports = ConstPlugin;
 
 ConstPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
-	compiler.parser.plugin("statement if", function(statement) {
-		var param = this.evaluateExpression(statement.test);
-		var bool = param.asBool();
-		if(typeof bool === "boolean") {
-			if(statement.test.type !== "Literal") {
-				var dep = new ConstDependency(bool + "", param.range);
-				dep.loc = statement.loc;
-				this.state.current.addDependency(dep);
-			}
-			return bool;
-		}
-	});
-	compiler.parser.plugin("expression ?:", function(expression) {
-		var param = this.evaluateExpression(expression.test);
-		var bool = param.asBool();
-		if(typeof bool === "boolean") {
-			if(expression.test.type !== "Literal") {
-				var dep = new ConstDependency(" " + bool + "", param.range);
-				dep.loc = expression.loc;
-				this.state.current.addDependency(dep);
-			}
-			return bool;
-		}
-	});
-	compiler.parser.plugin("evaluate Identifier __resourceQuery", function(expr) {
-		if(!this.state.module) return;
-		var res = new BasicEvaluatedExpression();
-		res.setString(getQuery(this.state.module.resource));
-		res.setRange(expr.range);
-		return res;
-	});
-	compiler.parser.plugin("expression __resourceQuery", function() {
-		if(!this.state.module) return;
-		this.state.current.addVariable("__resourceQuery", JSON.stringify(getQuery(this.state.module.resource)));
-		return true;
+
+		params.normalModuleFactory.plugin("parser", function(parser) {
+			parser.plugin("statement if", function(statement) {
+				var param = this.evaluateExpression(statement.test);
+				var bool = param.asBool();
+				if(typeof bool === "boolean") {
+					if(statement.test.type !== "Literal") {
+						var dep = new ConstDependency(bool + "", param.range);
+						dep.loc = statement.loc;
+						this.state.current.addDependency(dep);
+					}
+					return bool;
+				}
+			});
+			parser.plugin("expression ?:", function(expression) {
+				var param = this.evaluateExpression(expression.test);
+				var bool = param.asBool();
+				if(typeof bool === "boolean") {
+					if(expression.test.type !== "Literal") {
+						var dep = new ConstDependency(" " + bool + "", param.range);
+						dep.loc = expression.loc;
+						this.state.current.addDependency(dep);
+					}
+					return bool;
+				}
+			});
+			parser.plugin("evaluate Identifier __resourceQuery", function(expr) {
+				if(!this.state.module) return;
+				var res = new BasicEvaluatedExpression();
+				res.setString(getQuery(this.state.module.resource));
+				res.setRange(expr.range);
+				return res;
+			});
+			parser.plugin("expression __resourceQuery", function() {
+				if(!this.state.module) return;
+				this.state.current.addVariable("__resourceQuery", JSON.stringify(getQuery(this.state.module.resource)));
+				return true;
+			});
+		});
 	});
 };

package/lib/DefinePlugin.js

@@ -12,115 +12,119 @@ function DefinePlugin(definitions) {
 }
 module.exports = DefinePlugin;
 DefinePlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	var definitions = this.definitions;
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
-	});
-	(function walkDefinitions(definitions, prefix) {
-		Object.keys(definitions).forEach(function(key) {
-			var code = definitions[key];
-			if(code && typeof code === "object" && !(code instanceof RegExp)) {
-				walkDefinitions(code, prefix + key + ".");
-				applyObjectDefine(prefix + key, code);
-				return;
-			}
-			applyDefineKey(prefix, key);
-			applyDefine(prefix + key, code);
-		});
-	}(this.definitions, ""));
 
-	function stringifyObj(obj) {
-		return "{" + Object.keys(obj).map(function(key) {
-			var code = obj[key];
-			return JSON.stringify(key) + ":" + toCode(code);
-		}).join(",") + "}";
-	}
+		params.normalModuleFactory.plugin("parser", function(parser) {
+			(function walkDefinitions(definitions, prefix) {
+				Object.keys(definitions).forEach(function(key) {
+					var code = definitions[key];
+					if(code && typeof code === "object" && !(code instanceof RegExp)) {
+						walkDefinitions(code, prefix + key + ".");
+						applyObjectDefine(prefix + key, code);
+						return;
+					}
+					applyDefineKey(prefix, key);
+					applyDefine(prefix + key, code);
+				});
+			}(definitions, ""));
 
-	function toCode(code) {
-		if(code === null) return "null";
-		else if(code === undefined) return "undefined";
-		else if(code instanceof RegExp && code.toString) return code.toString();
-		else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
-		else if(typeof code === "object") return stringifyObj(code);
-		else return code + "";
-	}
+			function stringifyObj(obj) {
+				return "{" + Object.keys(obj).map(function(key) {
+					var code = obj[key];
+					return JSON.stringify(key) + ":" + toCode(code);
+				}).join(",") + "}";
+			}
 
-	function applyDefineKey(prefix, key) {
-		var splittedKey = key.split(".");
-		splittedKey.slice(1).forEach(function(_, i) {
-			var fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-			compiler.parser.plugin("can-rename " + fullKey, function() {
-				return true;
-			});
-		});
-	}
+			function toCode(code) {
+				if(code === null) return "null";
+				else if(code === undefined) return "undefined";
+				else if(code instanceof RegExp && code.toString) return code.toString();
+				else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
+				else if(typeof code === "object") return stringifyObj(code);
+				else return code + "";
+			}
 
-	function applyDefine(key, code) {
-		var isTypeof = /^typeof\s+/.test(key);
-		if(isTypeof) key = key.replace(/^typeof\s+/, "");
-		var recurse = false;
-		var recurseTypeof = false;
-		code = toCode(code);
-		if(!isTypeof) {
-			compiler.parser.plugin("can-rename " + key, function() {
-				return true;
-			});
-			compiler.parser.plugin("evaluate Identifier " + key, function(expr) {
-				if(recurse) return;
-				recurse = true;
-				var res = compiler.parser.evaluate(code);
-				recurse = false;
-				res.setRange(expr.range);
-				return res;
-			});
-			compiler.parser.plugin("expression " + key, function(expr) {
-				var dep = new ConstDependency(code, expr.range);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				return true;
-			});
-		}
-		var typeofCode = isTypeof ? code : "typeof (" + code + ")";
-		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
-			if(recurseTypeof) return;
-			recurseTypeof = true;
-			var res = compiler.parser.evaluate(typeofCode);
-			recurseTypeof = false;
-			res.setRange(expr.range);
-			return res;
-		});
-		compiler.parser.plugin("typeof " + key, function(expr) {
-			var res = compiler.parser.evaluate(typeofCode);
-			if(!res.isString()) return;
-			var dep = new ConstDependency(JSON.stringify(res.string), expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-	}
+			function applyDefineKey(prefix, key) {
+				var splittedKey = key.split(".");
+				splittedKey.slice(1).forEach(function(_, i) {
+					var fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
+					parser.plugin("can-rename " + fullKey, function() {
+						return true;
+					});
+				});
+			}
 
-	function applyObjectDefine(key, obj) {
-		var code = stringifyObj(obj);
-		compiler.parser.plugin("can-rename " + key, function() {
-			return true;
-		});
-		compiler.parser.plugin("evaluate Identifier " + key, function(expr) {
-			return new BasicEvaluatedExpression().setRange(expr.range);
-		});
-		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
-			return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
-		});
-		compiler.parser.plugin("expression " + key, function(expr) {
-			var dep = new ConstDependency(code, expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-		compiler.parser.plugin("typeof " + key, function(expr) {
-			var dep = new ConstDependency("\"object\"", expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
+			function applyDefine(key, code) {
+				var isTypeof = /^typeof\s+/.test(key);
+				if(isTypeof) key = key.replace(/^typeof\s+/, "");
+				var recurse = false;
+				var recurseTypeof = false;
+				code = toCode(code);
+				if(!isTypeof) {
+					parser.plugin("can-rename " + key, function() {
+						return true;
+					});
+					parser.plugin("evaluate Identifier " + key, function(expr) {
+						if(recurse) return;
+						recurse = true;
+						var res = this.evaluate(code);
+						recurse = false;
+						res.setRange(expr.range);
+						return res;
+					});
+					parser.plugin("expression " + key, function(expr) {
+						var dep = new ConstDependency(code, expr.range);
+						dep.loc = expr.loc;
+						this.state.current.addDependency(dep);
+						return true;
+					});
+				}
+				var typeofCode = isTypeof ? code : "typeof (" + code + ")";
+				parser.plugin("evaluate typeof " + key, function(expr) {
+					if(recurseTypeof) return;
+					recurseTypeof = true;
+					var res = this.evaluate(typeofCode);
+					recurseTypeof = false;
+					res.setRange(expr.range);
+					return res;
+				});
+				parser.plugin("typeof " + key, function(expr) {
+					var res = this.evaluate(typeofCode);
+					if(!res.isString()) return;
+					var dep = new ConstDependency(JSON.stringify(res.string), expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
+
+			function applyObjectDefine(key, obj) {
+				var code = stringifyObj(obj);
+				parser.plugin("can-rename " + key, function() {
+					return true;
+				});
+				parser.plugin("evaluate Identifier " + key, function(expr) {
+					return new BasicEvaluatedExpression().setRange(expr.range);
+				});
+				parser.plugin("evaluate typeof " + key, function(expr) {
+					return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
+				});
+				parser.plugin("expression " + key, function(expr) {
+					var dep = new ConstDependency(code, expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+				parser.plugin("typeof " + key, function(expr) {
+					var dep = new ConstDependency("\"object\"", expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
 		});
-	}
+	});
 };

package/lib/DelegatedModule.js

@@ -17,8 +17,7 @@ function DelegatedModule(sourceRequest, data, type, userRequest) {
 	this.userRequest = userRequest;
 	this.built = false;
 	this.usedExports = true;
-	this.hasStarExport = data.hasStarExport;
-	this.activeExports = data.activeExports;
+	this.providedExports = data.exports || true;
 }
 module.exports = DelegatedModule;
 

package/lib/Dependency.js

@@ -20,6 +20,11 @@ Dependency.prototype.getReference = function() {
 	}
 };
 
+// Returns the exported names
+Dependency.prototype.getExports = function() {
+	return null;
+};
+
 Dependency.prototype.getWarnings = function() {
 	return null;
 };

package/lib/DllReferencePlugin.js

@@ -2,25 +2,51 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var DelegatedPlugin = require("./DelegatedPlugin");
-var ExternalsPlugin = require("./ExternalsPlugin");
+var DelegatedSourceDependency = require("./dependencies/DelegatedSourceDependency");
+var DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
+var ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
 
 function DllReferencePlugin(options) {
 	this.options = options;
 }
 module.exports = DllReferencePlugin;
 DllReferencePlugin.prototype.apply = function(compiler) {
-	var name = this.options.name || this.options.manifest.name;
-	var sourceType = this.options.sourceType || "var";
-	var externals = {};
-	var source = "dll-reference " + name;
-	externals[source] = name;
-	compiler.apply(new ExternalsPlugin(sourceType, externals));
-	compiler.apply(new DelegatedPlugin({
-		source: source,
-		type: this.options.type,
-		scope: this.options.scope,
-		context: this.options.context,
-		content: this.options.content || this.options.manifest.content
-	}));
+	compiler.plugin("compilation", function(compilation, params) {
+		var normalModuleFactory = params.normalModuleFactory;
+
+		compilation.dependencyFactories.set(DelegatedSourceDependency, normalModuleFactory);
+	});
+	compiler.plugin("before-compile", function(params, callback) {
+		var manifest = this.options.manifest;
+		if(typeof manifest === "string") {
+			params.compilationDependencies.push(manifest);
+			compiler.inputFileSystem.readFile(manifest, function(err, result) {
+				if(err) return callback(err);
+				params["dll reference " + manifest] = JSON.parse(result.toString("utf-8"));
+				return callback();
+			});
+		} else {
+			return callback();
+		}
+	}.bind(this));
+	compiler.plugin("compile", function(params) {
+		var manifest = this.options.manifest;
+		if(typeof manifest === "string") {
+			manifest = params["dll reference " + manifest];
+		}
+		var name = this.options.name || manifest.name;
+		var sourceType = this.options.sourceType || "var";
+		var externals = {};
+		var source = "dll-reference " + name;
+		externals[source] = name;
+		params.normalModuleFactory.apply(new ExternalModuleFactoryPlugin(sourceType, externals));
+		params.normalModuleFactory.apply(new DelegatedModuleFactoryPlugin({
+			source: source,
+			type: this.options.type,
+			scope: this.options.scope,
+			context: this.options.context || compiler.options.context,
+			content: this.options.content || manifest.content,
+			extensions: this.options.extensions
+		}));
+	}.bind(this));
 };

package/lib/ExtendedAPIPlugin.js

@@ -17,7 +17,7 @@ var REPLACEMENT_TYPES = {
 	__webpack_hash__: "string" // eslint-disable-line camelcase
 };
 ExtendedAPIPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
+	compiler.plugin("compilation", function(compilation, params) {
 		compilation.dependencyFactories.set(ConstDependency, new NullFactory());
 		compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
 		compilation.mainTemplate.plugin("require-extensions", function(source, chunk, hash) {
@@ -30,16 +30,19 @@ ExtendedAPIPlugin.prototype.apply = function(compiler) {
 		compilation.mainTemplate.plugin("global-hash", function() {
 			return true;
 		});
-	});
-	Object.keys(REPLACEMENTS).forEach(function(key) {
-		compiler.parser.plugin("expression " + key, function(expr) {
-			var dep = new ConstDependency(REPLACEMENTS[key], expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-		compiler.parser.plugin("evaluate typeof " + key, function(expr) {
-			return new BasicEvaluatedExpression().setString(REPLACEMENT_TYPES[key]).setRange(expr.range);
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+			Object.keys(REPLACEMENTS).forEach(function(key) {
+				parser.plugin("expression " + key, function(expr) {
+					var dep = new ConstDependency(REPLACEMENTS[key], expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+				parser.plugin("evaluate typeof " + key, function(expr) {
+					return new BasicEvaluatedExpression().setString(REPLACEMENT_TYPES[key]).setRange(expr.range);
+				});
+			});
 		});
 	});
 };

package/lib/FlagDependencyExportsPlugin.js

@@ -0,0 +1,102 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function FlagDependencyExportsPlugin() {
+
+}
+module.exports = FlagDependencyExportsPlugin;
+
+FlagDependencyExportsPlugin.prototype.apply = function(compiler) {
+	compiler.plugin("compilation", function(compilation) {
+		compilation.plugin("finish-modules", function(modules) {
+
+			var dependencies = {};
+
+			var module, moduleWithExports;
+			var queue = modules.filter(function(m) {
+				return !m.providedExports;
+			});
+			for(var i = 0; i < queue.length; i++) {
+				module = queue[i];
+
+				if(module.providedExports !== true) {
+					moduleWithExports = false;
+					processDependenciesBlock(module);
+					if(!moduleWithExports) {
+						module.providedExports = true;
+						notifyDependencies();
+					}
+				}
+			}
+
+			function processDependenciesBlock(depBlock) {
+				depBlock.dependencies.forEach(function(dep) {
+					processDependency(dep);
+				});
+				depBlock.variables.forEach(function(variable) {
+					variable.dependencies.forEach(function(dep) {
+						processDependency(dep);
+					});
+				});
+				depBlock.blocks.forEach(function(block) {
+					processDependenciesBlock(block);
+				});
+			}
+
+			function processDependency(dep, usedExports) {
+				var exportDesc = dep.getExports && dep.getExports();
+				if(!exportDesc) return;
+				moduleWithExports = true;
+				var exports = exportDesc.exports;
+				var exportDeps = exportDesc.dependencies;
+				if(exportDeps) {
+					exportDeps.forEach(function(dep) {
+						var depIdent = dep.identifier();
+						var array = dependencies["$" + depIdent];
+						if(!array) array = dependencies["$" + depIdent] = [];
+						if(array.indexOf(module) < 0)
+							array.push(module);
+					});
+				}
+				var changed = false;
+				if(module.providedExports !== true) {
+					if(exports === true) {
+						module.providedExports = true;
+						changed = true;
+					} else if(Array.isArray(exports)) {
+						if(Array.isArray(module.providedExports)) {
+							changed = addToSet(module.providedExports, exports);
+						} else {
+							module.providedExports = exports.slice();
+							changed = true;
+						}
+					};
+				}
+				if(changed) {
+					notifyDependencies();
+				}
+			}
+
+			function notifyDependencies() {
+				var deps = dependencies["$" + module.identifier()];
+				if(deps) {
+					deps.forEach(function(dep) {
+						queue.push(dep);
+					});
+				}
+			}
+		});
+
+		function addToSet(a, b) {
+			var changed = false;
+			b.forEach(function(item) {
+				if(a.indexOf(item) < 0) {
+					a.push(item);
+					changed = true;
+				}
+			});
+			return changed;
+		}
+	});
+};

package/lib/FlagInitialModulesAsUsedPlugin.js

@@ -1,23 +1,23 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var path = require("path");
-var async = require("async");
-
-function FlagInitialModulesAsUsedPlugin() {}
-module.exports = FlagInitialModulesAsUsedPlugin;
-FlagInitialModulesAsUsedPlugin.prototype.apply = function(compiler) {
-	compiler.plugin("compilation", function(compilation) {
-		compilation.plugin("after-optimize-chunks", function(chunks) {
-			chunks.forEach(function(chunk) {
-				if(!chunk.isInitial()) {
-					return;
-				}
-				chunk.modules.forEach(function(module) {
-					module.usedExports = true;
-				});
-			});
-		});
-	});
-};
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var path = require("path");
+var async = require("async");
+
+function FlagInitialModulesAsUsedPlugin() {}
+module.exports = FlagInitialModulesAsUsedPlugin;
+FlagInitialModulesAsUsedPlugin.prototype.apply = function(compiler) {
+	compiler.plugin("compilation", function(compilation) {
+		compilation.plugin("after-optimize-chunks", function(chunks) {
+			chunks.forEach(function(chunk) {
+				if(!chunk.isInitial()) {
+					return;
+				}
+				chunk.modules.forEach(function(module) {
+					module.usedExports = true;
+				});
+			});
+		});
+	});
+};

package/lib/FunctionModuleTemplatePlugin.js

@@ -25,6 +25,10 @@ FunctionModuleTemplatePlugin.prototype.apply = function(moduleTemplate) {
 		if(this.outputOptions.pathinfo) {
 			var source = new ConcatSource();
 			var req = module.readableIdentifier(this.requestShortener);
+			if(Array.isArray(module.providedExports))
+				source.add("/* exports provided: " + module.providedExports.join(", ") + " */\n");
+			else if(module.providedExports)
+				source.add("/* unknown exports provided */\n");
 			if(Array.isArray(module.usedExports))
 				source.add("/* exports used: " + module.usedExports.join(", ") + " */\n");
 			else if(module.usedExports)

package/lib/HotModuleReplacement.runtime.js

@@ -2,7 +2,7 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-/*global $hash$ installedModules $require$ hotDownloadManifest hotDownloadUpdateChunk modules */
+/*global $hash$ installedModules $require$ hotDownloadManifest hotDownloadUpdateChunk hotDisposeChunk modules */
 module.exports = function() {
 
 	var hotApplyOnUpdate = true;