webpack 2.2.0-rc.6 → 2.2.1

package/lib/NormalModuleReplacementPlugin.js

@@ -2,39 +2,44 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
+"use strict";
 
-var path = require("path");
+const path = require("path");
 
-function NormalModuleReplacementPlugin(resourceRegExp, newResource) {
-	this.resourceRegExp = resourceRegExp;
-	this.newResource = newResource;
-}
-module.exports = NormalModuleReplacementPlugin;
-NormalModuleReplacementPlugin.prototype.apply = function(compiler) {
-	var resourceRegExp = this.resourceRegExp;
-	var newResource = this.newResource;
-	compiler.plugin("normal-module-factory", function(nmf) {
-		nmf.plugin("before-resolve", function(result, callback) {
-			if(!result) return callback();
-			if(resourceRegExp.test(result.request)) {
-				if(typeof newResource === "function") {
-					newResource(result);
-				} else {
-					result.request = newResource;
+class NormalModuleReplacementPlugin {
+	constructor(resourceRegExp, newResource) {
+		this.resourceRegExp = resourceRegExp;
+		this.newResource = newResource;
+	}
+
+	apply(compiler) {
+		let resourceRegExp = this.resourceRegExp;
+		let newResource = this.newResource;
+		compiler.plugin("normal-module-factory", (nmf) => {
+			nmf.plugin("before-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.request)) {
+					if(typeof newResource === "function") {
+						newResource(result);
+					} else {
+						result.request = newResource;
+					}
 				}
-			}
-			return callback(null, result);
-		});
-		nmf.plugin("after-resolve", function(result, callback) {
-			if(!result) return callback();
-			if(resourceRegExp.test(result.resource)) {
-				if(typeof newResource === "function") {
-					newResource(result);
-				} else {
-					result.resource = path.resolve(path.dirname(result.resource), newResource);
+				return callback(null, result);
+			});
+			nmf.plugin("after-resolve", (result, callback) => {
+				if(!result) return callback();
+				if(resourceRegExp.test(result.resource)) {
+					if(typeof newResource === "function") {
+						newResource(result);
+					} else {
+						result.resource = path.resolve(path.dirname(result.resource), newResource);
+					}
 				}
-			}
-			return callback(null, result);
+				return callback(null, result);
+			});
 		});
-	});
-};
+	}
+}
+
+module.exports = NormalModuleReplacementPlugin;

package/lib/Parser.js

@@ -421,6 +421,8 @@ Parser.prototype.walkStatements = function walkStatements(statements) {
 Parser.prototype.isHoistedStatement = function isHoistedStatement(statement) {
 	switch(statement.type) {
 		case "ImportDeclaration":
+		case "ExportAllDeclaration":
+		case "ExportNamedDeclaration":
 			return true;
 	}
 	return false;
@@ -621,7 +623,7 @@ Parser.prototype.walkExportDefaultDeclaration = function walkExportDefaultDeclar
 Parser.prototype.walkExportAllDeclaration = function walkExportAllDeclaration(statement) {
 	var source = statement.source.value;
 	this.applyPluginsBailResult("export import", statement, source);
-	this.applyPluginsBailResult("export import specifier", statement, source, null, null);
+	this.applyPluginsBailResult("export import specifier", statement, source, null, null, 0);
 };
 
 Parser.prototype.walkVariableDeclaration = function walkVariableDeclaration(statement) {
@@ -842,9 +844,9 @@ Parser.prototype.walkClassExpression = function walkClassExpression(expression)
 Parser.prototype.walkCallExpression = function walkCallExpression(expression) {
 	var result;
 
-	function walkIIFE(functionExpression, args) {
+	function walkIIFE(functionExpression, options) {
 		var params = functionExpression.params;
-		args = args.map(function(arg) {
+		var args = options.map(function(arg) {
 			var renameIdentifier = this.getRenameIdentifier(arg);
 			if(renameIdentifier && this.applyPluginsBailResult1("can-rename " + renameIdentifier, arg)) {
 				if(!this.applyPluginsBailResult1("rename " + renameIdentifier, arg))
@@ -855,11 +857,12 @@ Parser.prototype.walkCallExpression = function walkCallExpression(expression) {
 		this.inScope(params.filter(function(identifier, idx) {
 			return !args[idx];
 		}), function() {
-			args.forEach(function(arg, idx) {
-				if(!arg) return;
-				if(!params[idx] || params[idx].type !== "Identifier") return;
-				this.scope.renames["$" + params[idx].name] = arg;
-			}, this);
+			for(var i = 0; i < args.length; i++) {
+				var param = args[i];
+				if(!param) continue;
+				if(!params[i] || params[i].type !== "Identifier") continue;
+				this.scope.renames["$" + params[i].name] = param;
+			}
 			if(functionExpression.body.type === "BlockStatement")
 				this.walkStatement(functionExpression.body);
 			else

package/lib/ParserHelpers.js

@@ -25,22 +25,28 @@ ParserHelpers.addParsedVariableToModule = function(parser, name, expression) {
 	return true;
 };
 
-ParserHelpers.toConstantDependency = function toConstantDependency(value) {
-	return function constantDependency(expr) {
-		var dep = new ConstDependency(JSON.stringify(value), expr.range);
+ParserHelpers.toConstantDependency = function(value) {
+	return function constDependency(expr) {
+		var dep = new ConstDependency(value, expr.range);
 		dep.loc = expr.loc;
 		this.state.current.addDependency(dep);
 		return true;
 	};
 };
 
-ParserHelpers.evaluateToString = function evaluateToString(value) {
+ParserHelpers.evaluateToString = function(value) {
 	return function stringExpression(expr) {
 		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
 	};
 };
 
-ParserHelpers.expressionIsUnsupported = function expressionIsUnsupported(message) {
+ParserHelpers.evaluateToBoolean = function(value) {
+	return function booleanExpression(expr) {
+		return new BasicEvaluatedExpression().setBoolean(value).setRange(expr.range);
+	};
+};
+
+ParserHelpers.expressionIsUnsupported = function(message) {
 	return function unsupportedExpression(expr) {
 		var dep = new ConstDependency("(void 0)", expr.range);
 		dep.loc = expr.loc;
@@ -50,3 +56,11 @@ ParserHelpers.expressionIsUnsupported = function expressionIsUnsupported(message
 		return true;
 	};
 };
+
+ParserHelpers.skipTraversal = function skipTraversal() {
+	return true;
+};
+
+ParserHelpers.approve = function approve() {
+	return true;
+};

package/lib/ProvidePlugin.js

@@ -23,9 +23,7 @@ ProvidePlugin.prototype.apply = function(compiler) {
 				if(splittedName.length > 0) {
 					splittedName.slice(1).forEach(function(_, i) {
 						var name = splittedName.slice(0, i + 1).join(".");
-						parser.plugin("can-rename " + name, function() {
-							return true;
-						});
+						parser.plugin("can-rename " + name, ParserHelpers.approve);
 					});
 				}
 				parser.plugin("expression " + name, function(expr) {
@@ -44,9 +42,7 @@ ProvidePlugin.prototype.apply = function(compiler) {
 						return false;
 					}
 					if(scopedName) {
-						var dep = new ConstDependency(nameIdentifier, expr.range);
-						dep.loc = expr.loc;
-						this.state.current.addDependency(dep);
+						ParserHelpers.toConstantDependency(nameIdentifier).bind(this)(expr);
 					}
 					return true;
 				});

package/lib/RequestShortener.js

@@ -2,55 +2,57 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
-var path = require("path");
-
-function RequestShortener(directory) {
-	directory = directory.replace(/\\/g, "/");
-	var parentDirectory = path.dirname(directory);
-	if(/[\/\\]$/.test(directory)) directory = directory.substr(0, directory.length - 1);
-	if(directory) {
-		var currentDirectoryRegExp = directory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-		currentDirectoryRegExp = new RegExp("^" + currentDirectoryRegExp + "|(!)" + currentDirectoryRegExp, "g");
-
-		this.currentDirectoryRegExp = currentDirectoryRegExp;
+"use strict";
+
+const path = require("path");
+
+class RequestShortener {
+	constructor(directory) {
+		directory = directory.replace(/\\/g, "/");
+		let parentDirectory = path.dirname(directory);
+		if(/[\/\\]$/.test(directory)) directory = directory.substr(0, directory.length - 1);
+
+		if(directory) {
+			let currentDirectoryRegExp = directory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+			currentDirectoryRegExp = new RegExp("^" + currentDirectoryRegExp + "|(!)" + currentDirectoryRegExp, "g");
+			this.currentDirectoryRegExp = currentDirectoryRegExp;
+		}
+
+		if(/[\/\\]$/.test(parentDirectory)) parentDirectory = parentDirectory.substr(0, parentDirectory.length - 1);
+		if(parentDirectory && parentDirectory !== directory) {
+			let parentDirectoryRegExp = parentDirectory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+			parentDirectoryRegExp = new RegExp("^" + parentDirectoryRegExp + "|(!)" + parentDirectoryRegExp, "g");
+			this.parentDirectoryRegExp = parentDirectoryRegExp;
+		}
+
+		if(__dirname.length >= 2) {
+			let buildins = path.join(__dirname, "..").replace(/\\/g, "/");
+			let buildinsAsModule = this.currentDirectoryRegExp && this.currentDirectoryRegExp.test(buildins);
+			let buildinsRegExp = buildins.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+			buildinsRegExp = new RegExp("^" + buildinsRegExp + "|(!)" + buildinsRegExp, "g");
+			this.buildinsAsModule = buildinsAsModule;
+			this.buildinsRegExp = buildinsRegExp;
+		}
+
+		this.nodeModulesRegExp = /\/node_modules\//g;
+		this.indexJsRegExp = /\/index.js(!|\?|\(query\))/g;
 	}
 
-	if(/[\/\\]$/.test(parentDirectory)) parentDirectory = parentDirectory.substr(0, parentDirectory.length - 1);
-	if(parentDirectory && parentDirectory !== directory) {
-		var parentDirectoryRegExp = parentDirectory.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-		parentDirectoryRegExp = new RegExp("^" + parentDirectoryRegExp + "|(!)" + parentDirectoryRegExp, "g");
-
-		this.parentDirectoryRegExp = parentDirectoryRegExp;
+	shorten(request) {
+		if(!request) return request;
+		request = request.replace(/\\/g, "/");
+		if(this.buildinsAsModule && this.buildinsRegExp)
+			request = request.replace(this.buildinsRegExp, "!(webpack)");
+		if(this.currentDirectoryRegExp)
+			request = request.replace(this.currentDirectoryRegExp, "!.");
+		if(this.parentDirectoryRegExp)
+			request = request.replace(this.parentDirectoryRegExp, "!..");
+		if(!this.buildinsAsModule && this.buildinsRegExp)
+			request = request.replace(this.buildinsRegExp, "!(webpack)");
+		request = request.replace(this.nodeModulesRegExp, "/~/");
+		request = request.replace(this.indexJsRegExp, "$1");
+		return request.replace(/^!|!$/, "");
 	}
-
-	if(__dirname.length >= 2) {
-		var buildins = path.join(__dirname, "..").replace(/\\/g, "/");
-		var buildinsAsModule = currentDirectoryRegExp && currentDirectoryRegExp.test(buildins);
-		var buildinsRegExp = buildins.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-		buildinsRegExp = new RegExp("^" + buildinsRegExp + "|(!)" + buildinsRegExp, "g");
-
-		this.buildinsAsModule = buildinsAsModule;
-		this.buildinsRegExp = buildinsRegExp;
-	}
-
-	this.nodeModulesRegExp = /\/node_modules\//g;
-	this.indexJsRegExp = /\/index.js(!|\?|\(query\))/g;
 }
-module.exports = RequestShortener;
 
-RequestShortener.prototype.shorten = function(request) {
-	if(!request)
-		return request;
-	request = request.replace(/\\/g, "/");
-	if(this.buildinsAsModule && this.buildinsRegExp)
-		request = request.replace(this.buildinsRegExp, "!(webpack)");
-	if(this.currentDirectoryRegExp)
-		request = request.replace(this.currentDirectoryRegExp, "!.");
-	if(this.parentDirectoryRegExp)
-		request = request.replace(this.parentDirectoryRegExp, "!..");
-	if(!this.buildinsAsModule && this.buildinsRegExp)
-		request = request.replace(this.buildinsRegExp, "!(webpack)");
-	request = request.replace(this.nodeModulesRegExp, "/~/");
-	request = request.replace(this.indexJsRegExp, "$1");
-	return request.replace(/^!|!$/, "");
-};
+module.exports = RequestShortener;

package/lib/RequireJsStuffPlugin.js

@@ -4,6 +4,7 @@
 */
 "use strict";
 
+const ParserHelpers = require("./ParserHelpers");
 const ConstDependency = require("./dependencies/ConstDependency");
 const NullFactory = require("./NullFactory");
 
@@ -18,27 +19,11 @@ module.exports = class RequireJsStuffPlugin {
 				if(typeof parserOptions.requireJs !== "undefined" && !parserOptions.requireJs)
 					return;
 
-				function remove(expr) {
-					var dep = new ConstDependency(";", expr.range);
-					dep.loc = expr.loc;
-					this.state.current.addDependency(dep);
-					return true;
-				}
-				parser.plugin("call require.config", remove);
-				parser.plugin("call requirejs.config", remove);
+				parser.plugin("call require.config", ParserHelpers.toConstantDependency("undefined"));
+				parser.plugin("call requirejs.config", ParserHelpers.toConstantDependency("undefined"));
 
-				parser.plugin("expression require.version", function(expr) {
-					var dep = new ConstDependency(JSON.stringify("0.0.0"), expr.range);
-					dep.loc = expr.loc;
-					this.state.current.addDependency(dep);
-					return true;
-				});
-				parser.plugin("expression requirejs.onError", function(expr) {
-					var dep = new ConstDependency(JSON.stringify("__webpack_require__.oe"), expr.range);
-					dep.loc = expr.loc;
-					this.state.current.addDependency(dep);
-					return true;
-				});
+				parser.plugin("expression require.version", ParserHelpers.toConstantDependency(JSON.stringify("0.0.0")));
+				parser.plugin("expression requirejs.onError", ParserHelpers.toConstantDependency(JSON.stringify("__webpack_require__.oe")));
 			});
 		});
 	}

package/lib/RuleSet.js

@@ -69,27 +69,28 @@ normalized:
 }
 
 */
+"use strict";
 
 function RuleSet(rules) {
-	this.references = {};
-	this.rules = RuleSet.normalizeRules(rules, this.references);
+	this.references = Object.create(null);
+	this.rules = RuleSet.normalizeRules(rules, this.references, "ref-");
 }
 
 module.exports = RuleSet;
 
-RuleSet.normalizeRules = function(rules, refs) {
+RuleSet.normalizeRules = function(rules, refs, ident) {
 	if(Array.isArray(rules)) {
-		return rules.map(function(rule) {
-			return RuleSet.normalizeRule(rule, refs);
+		return rules.map(function(rule, idx) {
+			return RuleSet.normalizeRule(rule, refs, `${ident}-${idx}`);
 		});
 	} else if(rules) {
-		return [RuleSet.normalizeRule(rules, refs)];
+		return [RuleSet.normalizeRule(rules, refs, ident)];
 	} else {
 		return [];
 	}
 };
 
-RuleSet.normalizeRule = function(rule, refs) {
+RuleSet.normalizeRule = function(rule, refs, ident) {
 	if(typeof rule === "string")
 		return {
 			use: [{
@@ -151,33 +152,33 @@ RuleSet.normalizeRule = function(rule, refs) {
 	var loader = rule.loaders || rule.loader;
 	if(typeof loader === "string" && !rule.options && !rule.query) {
 		checkUseSource("loader");
-		newRule.use = RuleSet.normalizeUse(loader.split("!"));
+		newRule.use = RuleSet.normalizeUse(loader.split("!"), ident);
 	} else if(typeof loader === "string" && (rule.options || rule.query)) {
 		checkUseSource("loader + options/query");
 		newRule.use = RuleSet.normalizeUse({
 			loader: loader,
 			options: rule.options,
 			query: rule.query
-		});
+		}, ident);
 	} else if(loader && (rule.options || rule.query)) {
 		throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query cannot be used with loaders (use options for each array item)")));
 	} else if(loader) {
 		checkUseSource("loaders");
-		newRule.use = RuleSet.normalizeUse(loader);
+		newRule.use = RuleSet.normalizeUse(loader, ident);
 	} else if(rule.options || rule.query) {
 		throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query provided without loader (use loader + options)")));
 	}
 
 	if(rule.use) {
 		checkUseSource("use");
-		newRule.use = RuleSet.normalizeUse(rule.use);
+		newRule.use = RuleSet.normalizeUse(rule.use, ident);
 	}
 
 	if(rule.rules)
-		newRule.rules = RuleSet.normalizeRules(rule.rules, refs);
+		newRule.rules = RuleSet.normalizeRules(rule.rules, refs, `${ident}-rules`);
 
 	if(rule.oneOf)
-		newRule.oneOf = RuleSet.normalizeRules(rule.oneOf, refs);
+		newRule.oneOf = RuleSet.normalizeRules(rule.oneOf, refs, `${ident}-oneOf`);
 
 	var keys = Object.keys(rule).filter(function(key) {
 		return ["resource", "resourceQuery", "test", "include", "exclude", "issuer", "loader", "options", "query", "loaders", "use", "rules", "oneOf"].indexOf(key) < 0;
@@ -200,8 +201,8 @@ RuleSet.normalizeRule = function(rule, refs) {
 
 	if(Array.isArray(newRule.use)) {
 		newRule.use.forEach(function(item) {
-			if(typeof item.options === "object" && item.options && item.options.ident) {
-				refs["$" + item.options.ident] = item.options;
+			if(item.ident) {
+				refs[item.ident] = item.options;
 			}
 		});
 	}
@@ -217,13 +218,13 @@ RuleSet.buildErrorMessage = function buildErrorMessage(condition, error) {
 	return message;
 };
 
-RuleSet.normalizeUse = function normalizeUse(use) {
+RuleSet.normalizeUse = function normalizeUse(use, ident) {
 	if(Array.isArray(use)) {
-		return use.map(RuleSet.normalizeUse).reduce(function(arr, items) {
+		return use.map((item, idx) => RuleSet.normalizeUse(item, `${ident}-${idx}`)).reduce(function(arr, items) {
 			return arr.concat(items);
 		}, []);
 	}
-	return [RuleSet.normalizeUseItem(use)];
+	return [RuleSet.normalizeUseItem(use, ident)];
 };
 
 RuleSet.normalizeUseItemFunction = function normalizeUseItemFunction(use, data) {
@@ -247,7 +248,7 @@ RuleSet.normalizeUseItemString = function normalizeUseItemString(useItemString)
 	};
 };
 
-RuleSet.normalizeUseItem = function normalizeUseItem(item) {
+RuleSet.normalizeUseItem = function normalizeUseItem(item, ident) {
 	if(typeof item === "function")
 		return item;
 
@@ -265,6 +266,13 @@ RuleSet.normalizeUseItem = function normalizeUseItem(item) {
 
 	newItem.options = item.options || item.query;
 
+	if(typeof newItem.options === "object" && newItem.options) {
+		if(newItem.options.ident)
+			newItem.ident = newItem.options.ident;
+		else
+			newItem.ident = ident;
+	}
+
 	var keys = Object.keys(item).filter(function(key) {
 		return ["options", "query"].indexOf(key) < 0;
 	});
@@ -423,7 +431,7 @@ RuleSet.prototype._run = function _run(data, rule, result) {
 };
 
 RuleSet.prototype.findOptionsByIdent = function findOptionsByIdent(ident) {
-	var options = this.references["$" + ident];
+	var options = this.references[ident];
 	if(!options) throw new Error("Can't find options with ident '" + ident + "'");
 	return options;
 };

package/lib/SourceMapDevToolPlugin.js

@@ -155,7 +155,7 @@ SourceMapDevToolPlugin.prototype.apply = function(compiler) {
 						})
 						.replace(/\[url\]/g, function() {
 							return "data:application/json;charset=utf-8;base64," +
-								Buffer.from(JSON.stringify(sourceMap)).toString("base64");
+								new Buffer(JSON.stringify(sourceMap), "utf8").toString("base64"); //eslint-disable-line
 						})
 					);
 				}