added weak dependencies, require.resolveWeak

#526

lib/Compilation.js

@@ -567,7 +567,7 @@ Compilation.prototype.processDependenciesBlockForChunk = function processDepende
 		this.processDependenciesBlockForChunk(b, c);
 	}, this);
 	function iteratorDependency(d) {
-		if(!d.module) {
+		if(!d.module || d.weak) {
 			return;
 		}
 		if(d.module.error) {

lib/dependencies/CommonJsPlugin.js

@@ -23,6 +23,17 @@ function CommonJsPlugin(options) {
 module.exports = CommonJsPlugin;
 
 CommonJsPlugin.prototype.apply = function(compiler) {
+	function setTypeof(expr, value) {
+		compiler.parser.plugin("evaluate typeof " + expr, function(expr) {
+			return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+		});
+		compiler.parser.plugin("typeof " + expr, function(expr) {
+			var dep = new ConstDependency(JSON.stringify(value), expr.range);
+			dep.loc = expr.loc;
+			this.state.current.addDependency(dep);
+			return true;
+		});
+	}
 	compiler.plugin("compilation", function(compilation, params) {
 		var normalModuleFactory = params.normalModuleFactory;
 		var contextModuleFactory = params.contextModuleFactory;
@@ -45,9 +56,9 @@ CommonJsPlugin.prototype.apply = function(compiler) {
 		compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
 		compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
 	});
-	compiler.parser.plugin("evaluate typeof require", function(expr) {
+	setTypeof("require", "function");
-		return new BasicEvaluatedExpression().setString("function").setRange(expr.range);
+	setTypeof("require.resolve", "function");
-	});
+	setTypeof("require.resolveWeak", "function");
 	compiler.parser.plugin("evaluate typeof module", function(expr) {
 		return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
 	});

lib/dependencies/ModuleHotAcceptDependency.js

@@ -8,6 +8,7 @@ function ModuleHotAcceptDependency(request, range) {
 	ModuleDependency.call(this, request);
 	this.Class = ModuleHotAcceptDependency;
 	this.range = range;
+	this.weak = true;
 }
 module.exports = ModuleHotAcceptDependency;
 

lib/dependencies/ModuleHotDeclineDependency.js

@@ -8,6 +8,7 @@ function ModuleHotDeclineDependency(request, range) {
 	ModuleDependency.call(this, request);
 	this.Class = ModuleHotDeclineDependency;
 	this.range = range;
+	this.weak = true;
 }
 module.exports = ModuleHotDeclineDependency;
 

lib/dependencies/RequireResolveDependencyParserPlugin.js

@@ -16,40 +16,48 @@ module.exports = RequireResolveDependencyParserPlugin;
 RequireResolveDependencyParserPlugin.prototype.apply = function(parser) {
 	var options = this.options;
 	parser.plugin("call require.resolve", function(expr) {
+		return this.applyPluginsBailResult("call require.resolve(Weak)", expr, false)
+	});
+	parser.plugin("call require.resolveWeak", function(expr) {
+		return this.applyPluginsBailResult("call require.resolve(Weak)", expr, true)
+	});
+	parser.plugin("call require.resolve(Weak)", function(expr, weak) {
 		if(expr.arguments.length !== 1) return;
 		var param = this.evaluateExpression(expr.arguments[0]);
 		if(param.isConditional()) {
 			param.options.forEach(function(option) {
-				var result = this.applyPluginsBailResult("call require.resolve:item", expr, option);
+				var result = this.applyPluginsBailResult("call require.resolve(Weak):item", expr, option, weak);
 				if(result === undefined) {
-					this.applyPluginsBailResult("call require.resolve:context", expr, option);
+					this.applyPluginsBailResult("call require.resolve(Weak):context", expr, option, weak);
 				}
 			}, this);
 			this.state.current.addDependency(new RequireResolveHeaderDependency(expr.callee.range));
 			return true;
 		} else {
-			var result = this.applyPluginsBailResult("call require.resolve:item", expr, param);
+			var result = this.applyPluginsBailResult("call require.resolve(Weak):item", expr, param, weak);
 			if(result === undefined) {
-				this.applyPluginsBailResult("call require.resolve:context", expr, param);
+				this.applyPluginsBailResult("call require.resolve(Weak):context", expr, param, weak);
 			}
 			this.state.current.addDependency(new RequireResolveHeaderDependency(expr.callee.range));
 			return true;
 		}
 	});
-	parser.plugin("call require.resolve:item", function(expr, param) {
+	parser.plugin("call require.resolve(Weak):item", function(expr, param, weak) {
 		if(param.isString()) {
 			var dep = new RequireResolveDependency(param.string, param.range);
 			dep.loc = expr.loc;
 			dep.optional = !!this.scope.inTry;
+			dep.weak = weak;
 			this.state.current.addDependency(dep);
 			return true;
 		}
 	});
-	parser.plugin("call require.resolve:context", function(expr, param) {
+	parser.plugin("call require.resolve(Weak):context", function(expr, param, weak) {
 		var dep = ContextDependencyHelpers.create(RequireResolveContextDependency, param.range, param, expr, options);
 		if(!dep) return;
 		dep.loc = expr.loc;
 		dep.optional = !!this.scope.inTry;
+		dep.weak = weak;
 		this.state.current.addDependency(dep);
 		return true;
 	});

test/cases/chunks/weak-dependencies/index.js

@@ -0,0 +1,13 @@
+it("should not include a module with a weak dependency", function() {
+	var a = !!__webpack_modules__[require.resolveWeak("./a")];
+	var b = !!__webpack_modules__[require.resolve("./b")];
+	var c = !!__webpack_modules__[require.resolveWeak("./c")];
+	var d = !!__webpack_modules__[require.resolveWeak("./d")];
+	require(["./c"]);
+	require("./d");
+	
+	a.should.be.eql(false);
+	b.should.be.eql(true);
+	c.should.be.eql(false);
+	d.should.be.eql(true);
+});