webpack 2.2.0 → 2.2.1

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -2,174 +2,177 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var AMDRequireItemDependency = require("./AMDRequireItemDependency");
-var AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
-var AMDRequireContextDependency = require("./AMDRequireContextDependency");
-var AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
-var UnsupportedDependency = require("./UnsupportedDependency");
-var LocalModuleDependency = require("./LocalModuleDependency");
-var ContextDependencyHelpers = require("./ContextDependencyHelpers");
-var LocalModulesHelpers = require("./LocalModulesHelpers");
-var ConstDependency = require("./ConstDependency");
-var getFunctionExpression = require("./getFunctionExpression");
-var UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+"use strict";
 
-function AMDRequireDependenciesBlockParserPlugin(options) {
-	this.options = options;
-}
+const AMDRequireItemDependency = require("./AMDRequireItemDependency");
+const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
+const AMDRequireContextDependency = require("./AMDRequireContextDependency");
+const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
+const UnsupportedDependency = require("./UnsupportedDependency");
+const LocalModuleDependency = require("./LocalModuleDependency");
+const ContextDependencyHelpers = require("./ContextDependencyHelpers");
+const LocalModulesHelpers = require("./LocalModulesHelpers");
+const ConstDependency = require("./ConstDependency");
+const getFunctionExpression = require("./getFunctionExpression");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 
-module.exports = AMDRequireDependenciesBlockParserPlugin;
+class AMDRequireDependenciesBlockParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-function processFunctionArgument(parser, expression) {
-	var bindThis = true;
-	var fnData = getFunctionExpression(expression);
-	if(fnData) {
-		parser.inScope(fnData.fn.params.filter(function(i) {
-			return ["require", "module", "exports"].indexOf(i.name) < 0;
-		}), function() {
-			if(fnData.fn.body.type === "BlockStatement")
-				parser.walkStatement(fnData.fn.body);
-			else
-				parser.walkExpression(fnData.fn.body);
-		});
-		parser.walkExpressions(fnData.expressions);
-		if(fnData.needThis === false) {
-			bindThis = false;
+	processFunctionArgument(parser, expression) {
+		let bindThis = true;
+		const fnData = getFunctionExpression(expression);
+		if(fnData) {
+			parser.inScope(fnData.fn.params.filter((i) => {
+				return ["require", "module", "exports"].indexOf(i.name) < 0;
+			}), () => {
+				if(fnData.fn.body.type === "BlockStatement")
+					parser.walkStatement(fnData.fn.body);
+				else
+					parser.walkExpression(fnData.fn.body);
+			});
+			parser.walkExpressions(fnData.expressions);
+			if(fnData.needThis === false) {
+				bindThis = false;
+			}
+		} else {
+			parser.walkExpression(expression);
 		}
-	} else {
-		parser.walkExpression(expression);
+		return bindThis;
 	}
-	return bindThis;
-}
 
-AMDRequireDependenciesBlockParserPlugin.prototype.apply = function(parser) {
-	var options = this.options;
-	parser.plugin("call require", function(expr) {
-		var param;
-		var dep;
-		var old;
-		var result;
+	apply(parser) {
+		const options = this.options;
+		parser.plugin("call require", (expr) => {
+			let param;
+			let dep;
+			let old;
+			let result;
 
-		old = this.state.current;
+			old = parser.state.current;
 
-		if(expr.arguments.length >= 1) {
-			param = this.evaluateExpression(expr.arguments[0]);
-			dep = new AMDRequireDependenciesBlock(
-				expr,
-				param.range,
-				(expr.arguments.length > 1) ? expr.arguments[1].range : null,
-				(expr.arguments.length > 2) ? expr.arguments[2].range : null,
-				this.state.module,
-				expr.loc
-			);
-			this.state.current = dep;
-		}
+			if(expr.arguments.length >= 1) {
+				param = parser.evaluateExpression(expr.arguments[0]);
+				dep = new AMDRequireDependenciesBlock(
+					expr,
+					param.range,
+					(expr.arguments.length > 1) ? expr.arguments[1].range : null,
+					(expr.arguments.length > 2) ? expr.arguments[2].range : null,
+					parser.state.module,
+					expr.loc
+				);
+				parser.state.current = dep;
+			}
 
-		if(expr.arguments.length === 1) {
-			this.inScope([], function() {
-				result = this.applyPluginsBailResult("call require:amd:array", expr, param);
-			}.bind(this));
-			this.state.current = old;
-			if(!result) return;
-			this.state.current.addBlock(dep);
-			return true;
-		}
+			if(expr.arguments.length === 1) {
+				parser.inScope([], () => {
+					result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
+				});
+				parser.state.current = old;
+				if(!result) return;
+				parser.state.current.addBlock(dep);
+				return true;
+			}
 
-		if(expr.arguments.length === 2 || expr.arguments.length === 3) {
-			try {
-				this.inScope([], function() {
-					result = this.applyPluginsBailResult("call require:amd:array", expr, param);
-				}.bind(this));
-				if(!result) {
-					dep = new UnsupportedDependency("unsupported", expr.range);
-					old.addDependency(dep);
-					if(this.state.module)
-						this.state.module.errors.push(new UnsupportedFeatureWarning(this.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line));
-					dep = null;
-					return true;
-				}
-				dep.functionBindThis = processFunctionArgument(this, expr.arguments[1]);
-				if(expr.arguments.length === 3) {
-					dep.errorCallbackBindThis = processFunctionArgument(this, expr.arguments[2]);
+			if(expr.arguments.length === 2 || expr.arguments.length === 3) {
+				try {
+					parser.inScope([], () => {
+						result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
+					});
+					if(!result) {
+						dep = new UnsupportedDependency("unsupported", expr.range);
+						old.addDependency(dep);
+						if(parser.state.module)
+							parser.state.module.errors.push(new UnsupportedFeatureWarning(parser.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line));
+						dep = null;
+						return true;
+					}
+					dep.functionBindThis = this.processFunctionArgument(parser, expr.arguments[1]);
+					if(expr.arguments.length === 3) {
+						dep.errorCallbackBindThis = this.processFunctionArgument(parser, expr.arguments[2]);
+					}
+				} finally {
+					parser.state.current = old;
+					if(dep)
+						parser.state.current.addBlock(dep);
 				}
-			} finally {
-				this.state.current = old;
-				if(dep)
-					this.state.current.addBlock(dep);
+				return true;
 			}
-			return true;
-		}
-	});
-	parser.plugin("call require:amd:array", function(expr, param) {
-		if(param.isArray()) {
-			param.items.forEach(function(param) {
-				var result = this.applyPluginsBailResult("call require:amd:item", expr, param);
-				if(result === undefined) {
-					this.applyPluginsBailResult("call require:amd:context", expr, param);
-				}
-			}, this);
-			return true;
-		} else if(param.isConstArray()) {
-			var deps = [];
-			param.array.forEach(function(request) {
-				var dep, localModule;
-				if(request === "require") {
-					dep = "__webpack_require__";
-				} else if(["exports", "module"].indexOf(request) >= 0) {
-					dep = request;
-				} else if(localModule = LocalModulesHelpers.getLocalModule(this.state, request)) { // eslint-disable-line no-cond-assign
-					dep = new LocalModuleDependency(localModule);
-					dep.loc = expr.loc;
-					this.state.current.addDependency(dep);
+		});
+		parser.plugin("call require:amd:array", (expr, param) => {
+			if(param.isArray()) {
+				param.items.forEach((param) => {
+					const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
+					if(result === undefined) {
+						parser.applyPluginsBailResult("call require:amd:context", expr, param);
+					}
+				});
+				return true;
+			} else if(param.isConstArray()) {
+				const deps = [];
+				param.array.forEach((request) => {
+					let dep, localModule;
+					if(request === "require") {
+						dep = "__webpack_require__";
+					} else if(["exports", "module"].indexOf(request) >= 0) {
+						dep = request;
+					} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign
+						dep = new LocalModuleDependency(localModule);
+						dep.loc = expr.loc;
+						parser.state.current.addDependency(dep);
+					} else {
+						dep = new AMDRequireItemDependency(request);
+						dep.loc = expr.loc;
+						dep.optional = !!parser.scope.inTry;
+						parser.state.current.addDependency(dep);
+					}
+					deps.push(dep);
+				});
+				const dep = new AMDRequireArrayDependency(deps, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		});
+		parser.plugin("call require:amd:item", (expr, param) => {
+			if(param.isConditional()) {
+				param.options.forEach((param) => {
+					const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
+					if(result === undefined) {
+						parser.applyPluginsBailResult("call require:amd:context", expr, param);
+					}
+				});
+				return true;
+			} else if(param.isString()) {
+				let dep, localModule;
+				if(param.string === "require") {
+					dep = new ConstDependency("__webpack_require__", param.string);
+				} else if(param.string === "module") {
+					dep = new ConstDependency(parser.state.module.moduleArgument || "module", param.range);
+				} else if(param.string === "exports") {
+					dep = new ConstDependency(parser.state.module.exportsArgument || "exports", param.range);
+				} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string)) { // eslint-disable-line no-cond-assign
+					dep = new LocalModuleDependency(localModule, param.range);
 				} else {
-					dep = new AMDRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!this.scope.inTry;
-					this.state.current.addDependency(dep);
-				}
-				deps.push(dep);
-			}, this);
-			var dep = new AMDRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!this.scope.inTry;
-			this.state.current.addDependency(dep);
-			return true;
-		}
-	});
-	parser.plugin("call require:amd:item", function(expr, param) {
-		if(param.isConditional()) {
-			param.options.forEach(function(param) {
-				var result = this.applyPluginsBailResult("call require:amd:item", expr, param);
-				if(result === undefined) {
-					this.applyPluginsBailResult("call require:amd:context", expr, param);
+					dep = new AMDRequireItemDependency(param.string, param.range);
 				}
-			}, this);
-			return true;
-		} else if(param.isString()) {
-			var dep, localModule;
-			if(param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.range);
-			} else if(param.string === "module") {
-				dep = new ConstDependency(this.state.module.moduleArgument || "module", param.range);
-			} else if(param.string === "exports") {
-				dep = new ConstDependency(this.state.module.exportsArgument || "exports", param.range);
-			} else if(localModule = LocalModulesHelpers.getLocalModule(this.state, param.string)) { // eslint-disable-line no-cond-assign
-				dep = new LocalModuleDependency(localModule, param.range);
-			} else {
-				dep = new AMDRequireItemDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
+		});
+		parser.plugin("call require:amd:context", (expr, param) => {
+			const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
+			if(!dep) return;
 			dep.loc = expr.loc;
-			dep.optional = !!this.scope.inTry;
-			this.state.current.addDependency(dep);
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
 			return true;
-		}
-	});
-	parser.plugin("call require:amd:context", function(expr, param) {
-		var dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
-		if(!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!this.scope.inTry;
-		this.state.current.addDependency(dep);
-		return true;
-	});
-};
+		});
+	}
+}
+module.exports = AMDRequireDependenciesBlockParserPlugin;

package/lib/dependencies/CommonJsPlugin.js

@@ -3,90 +3,86 @@
 	Author Tobias Koppers @sokra
 */
 "use strict";
-
-var ConstDependency = require("./ConstDependency");
-var CommonJsRequireDependency = require("./CommonJsRequireDependency");
-var CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
-var RequireResolveDependency = require("./RequireResolveDependency");
-var RequireResolveContextDependency = require("./RequireResolveContextDependency");
-var RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
-var RequireHeaderDependency = require("./RequireHeaderDependency");
-
-var NullFactory = require("../NullFactory");
-
-var RequireResolveDependencyParserPlugin = require("./RequireResolveDependencyParserPlugin");
-var CommonJsRequireDependencyParserPlugin = require("./CommonJsRequireDependencyParserPlugin");
-
-var ParserHelpers = require("../ParserHelpers");
-
-function CommonJsPlugin(options) {
-	this.options = options;
-}
-module.exports = CommonJsPlugin;
-
-CommonJsPlugin.prototype.apply = function(compiler) {
-	var options = this.options;
-	compiler.plugin("compilation", function(compilation, params) {
-		var normalModuleFactory = params.normalModuleFactory;
-		var contextModuleFactory = params.contextModuleFactory;
-
-		compilation.dependencyFactories.set(CommonJsRequireDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(CommonJsRequireDependency, new CommonJsRequireDependency.Template());
-
-		compilation.dependencyFactories.set(CommonJsRequireContextDependency, contextModuleFactory);
-		compilation.dependencyTemplates.set(CommonJsRequireContextDependency, new CommonJsRequireContextDependency.Template());
-
-		compilation.dependencyFactories.set(RequireResolveDependency, normalModuleFactory);
-		compilation.dependencyTemplates.set(RequireResolveDependency, new RequireResolveDependency.Template());
-
-		compilation.dependencyFactories.set(RequireResolveContextDependency, contextModuleFactory);
-		compilation.dependencyTemplates.set(RequireResolveContextDependency, new RequireResolveContextDependency.Template());
-
-		compilation.dependencyFactories.set(RequireResolveHeaderDependency, new NullFactory());
-		compilation.dependencyTemplates.set(RequireResolveHeaderDependency, new RequireResolveHeaderDependency.Template());
-
-		compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
-		compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
-
-		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
-
-			if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs)
-				return;
-
-			const requireExpressions = ["require", "require.resolve", "require.resolveWeak"];
-			for(const expression of requireExpressions) {
-				parser.plugin(`typeof ${expression}`, ParserHelpers.toConstantDependency("function"));
-				parser.plugin(`evaluate typeof ${expression}`, ParserHelpers.evaluateToString("function"));
-			}
-
-			parser.plugin("evaluate typeof module", ParserHelpers.evaluateToString("object"));
-			parser.plugin("assign require", function(expr) {
-				// to not leak to global "require", we need to define a local require here.
-				var dep = new ConstDependency("var require;", 0);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				this.scope.definitions.push("require");
-				return true;
+const ConstDependency = require("./ConstDependency");
+const CommonJsRequireDependency = require("./CommonJsRequireDependency");
+const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
+const RequireResolveDependency = require("./RequireResolveDependency");
+const RequireResolveContextDependency = require("./RequireResolveContextDependency");
+const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
+const RequireHeaderDependency = require("./RequireHeaderDependency");
+
+const NullFactory = require("../NullFactory");
+
+const RequireResolveDependencyParserPlugin = require("./RequireResolveDependencyParserPlugin");
+const CommonJsRequireDependencyParserPlugin = require("./CommonJsRequireDependencyParserPlugin");
+
+const ParserHelpers = require("../ParserHelpers");
+
+class CommonJsPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	apply(compiler) {
+		const options = this.options;
+		compiler.plugin("compilation", (compilation, params) => {
+			const normalModuleFactory = params.normalModuleFactory;
+			const contextModuleFactory = params.contextModuleFactory;
+
+			compilation.dependencyFactories.set(CommonJsRequireDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(CommonJsRequireDependency, new CommonJsRequireDependency.Template());
+
+			compilation.dependencyFactories.set(CommonJsRequireContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(CommonJsRequireContextDependency, new CommonJsRequireContextDependency.Template());
+
+			compilation.dependencyFactories.set(RequireResolveDependency, normalModuleFactory);
+			compilation.dependencyTemplates.set(RequireResolveDependency, new RequireResolveDependency.Template());
+
+			compilation.dependencyFactories.set(RequireResolveContextDependency, contextModuleFactory);
+			compilation.dependencyTemplates.set(RequireResolveContextDependency, new RequireResolveContextDependency.Template());
+
+			compilation.dependencyFactories.set(RequireResolveHeaderDependency, new NullFactory());
+			compilation.dependencyTemplates.set(RequireResolveHeaderDependency, new RequireResolveHeaderDependency.Template());
+
+			compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
+			compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
+
+			params.normalModuleFactory.plugin("parser", (parser, parserOptions) => {
+
+				if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs)
+					return;
+
+				const requireExpressions = ["require", "require.resolve", "require.resolveWeak"];
+				for(const expression of requireExpressions) {
+					parser.plugin(`typeof ${expression}`, ParserHelpers.toConstantDependency("function"));
+					parser.plugin(`evaluate typeof ${expression}`, ParserHelpers.evaluateToString("function"));
+				}
+
+				parser.plugin("evaluate typeof module", ParserHelpers.evaluateToString("object"));
+				parser.plugin("assign require", (expr) => {
+					// to not leak to global "require", we need to define a local require here.
+					const dep = new ConstDependency("var require;", 0);
+					dep.loc = expr.loc;
+					parser.state.current.addDependency(dep);
+					parser.scope.definitions.push("require");
+					return true;
+				});
+				parser.plugin("can-rename require", () => true);
+				parser.plugin("rename require", (expr) => {
+					// define the require variable. It's still undefined, but not "not defined".
+					const dep = new ConstDependency("var require;", 0);
+					dep.loc = expr.loc;
+					parser.state.current.addDependency(dep);
+					return false;
+				});
+				parser.plugin("typeof module", () => true);
+				parser.plugin("evaluate typeof exports", ParserHelpers.evaluateToString("object"));
+				parser.apply(
+					new CommonJsRequireDependencyParserPlugin(options),
+					new RequireResolveDependencyParserPlugin(options)
+				);
 			});
-			parser.plugin("can-rename require", function() {
-				return true;
-			});
-			parser.plugin("rename require", function(expr) {
-				// define the require variable. It's still undefined, but not "not defined".
-				var dep = new ConstDependency("var require;", 0);
-				dep.loc = expr.loc;
-				this.state.current.addDependency(dep);
-				return false;
-			});
-			parser.plugin("typeof module", function() {
-				return true;
-			});
-			parser.plugin("evaluate typeof exports", ParserHelpers.evaluateToString("object"));
-			parser.apply(
-				new CommonJsRequireDependencyParserPlugin(options),
-				new RequireResolveDependencyParserPlugin(options)
-			);
 		});
-	});
-
-};
+	}
+}
+module.exports = CommonJsPlugin;